Unordered: Merge unordered from trunk.

- Activate `std::allocator_traits` for gcc 4.7 and Visual C++ 11.
- Implement variadic construct in `boost::unordered::detail::allocator_traits`
  when variadics, rvalue references and SFINAE expression are available.
- Use variadic construct from `allocator_traits`, or when not available move
  the logic for constructing `value_type` to a lower level, so the container
  code is a bit simpler.
- Avoid `-Wshadow` warnings. Fixes #6190.
- Implement `reserve`. Fixes #6857.


[SVN r78432]

test/unordered/assign_tests.cpp

@@ -22,7 +22,7 @@
 
 namespace assign_tests {
 
-test::seed_t seed(96785);
+test::seed_t initialize_seed(96785);
 
 template <class T>
 void assign_tests1(T*,

test/unordered/bucket_tests.cpp

@@ -21,7 +21,7 @@
 
 namespace bucket_tests {
 
-test::seed_t seed(54635);
+test::seed_t initialize_seed(54635);
 
 template <class X>
 void tests(X* = 0, test::random_generator generator = test::default_generator)

test/unordered/constructor_tests.cpp

@@ -18,7 +18,7 @@
 
 namespace constructor_tests {
 
-test::seed_t seed(356730);
+test::seed_t initialize_seed(356730);
 
 template <class T>
 void constructor_tests1(T*,

test/unordered/copy_tests.cpp

@@ -16,7 +16,7 @@
 #include "../helpers/equivalent.hpp"
 #include "../helpers/invariants.hpp"
 
-test::seed_t seed(9063);
+test::seed_t initialize_seed(9063);
 
 namespace copy_tests
 {

test/unordered/erase_tests.cpp

@@ -21,7 +21,7 @@
 namespace erase_tests
 {
 
-test::seed_t seed(85638);
+test::seed_t initialize_seed(85638);
 
 template <class Container>
 void erase_tests1(Container*,

test/unordered/find_tests.cpp

@@ -17,7 +17,7 @@
 namespace find_tests
 {
 
-test::seed_t seed(78937);
+test::seed_t initialize_seed(78937);
 
 template <class X>
 void find_tests1(X*, test::random_generator generator = test::default_generator)

test/unordered/insert_tests.cpp

@@ -21,7 +21,7 @@
 
 namespace insert_tests {
     
-test::seed_t seed(243432);
+test::seed_t initialize_seed(243432);
 
 template <class X>
 void unique_insert_tests1(X*,

test/unordered/load_factor_tests.cpp

@@ -20,7 +20,7 @@
 namespace load_factor_tests
 {
 
-test::seed_t seed(783656);
+test::seed_t initialize_seed(783656);
 
 template <class X>
 void set_load_factor_tests(X* = 0)

test/unordered/move_tests.cpp

@@ -22,7 +22,7 @@
 
 namespace move_tests
 {
-    test::seed_t seed(98624);
+    test::seed_t initialize_seed(98624);
 #if defined(BOOST_UNORDERED_USE_MOVE) || !defined(BOOST_NO_RVALUE_REFERENCES)
 #define BOOST_UNORDERED_TEST_MOVING 1
 #else

test/unordered/rehash_tests.cpp

@@ -15,7 +15,7 @@
 namespace rehash_tests
 {
 
-test::seed_t seed(2974);
+test::seed_t initialize_seed(2974);
 
 template <class X>
 bool postcondition(X const& x, BOOST_DEDUCED_TYPENAME X::size_type n)
@@ -100,6 +100,75 @@ void rehash_test1(X* = 0,
     tracker.compare(x);
 }
 
+template <class X>
+void reserve_test1(X* = 0,
+    test::random_generator generator = test::default_generator)
+{
+    for (int random_mlf = 0; random_mlf < 2; ++random_mlf)
+    {
+        for (int i = 1; i < 2000; i += i < 50 ? 1 : 13)
+        {
+            test::random_values<X> v(i, generator);
+
+            test::ordered<X> tracker;
+            tracker.insert_range(v.begin(), v.end());
+
+            X x;
+            x.max_load_factor(random_mlf ?
+                static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f : 1.0f);
+
+            // For the current standard this should reserve i+1, I've
+            // submitted a defect report and will assume it's a defect
+            // for now.
+            x.reserve(i);
+
+            // Insert an element before the range insert, otherwise there are
+            // no iterators to invalidate in the range insert, and it can
+            // rehash.
+            typename test::random_values<X>::iterator it = v.begin();
+            x.insert(*it);
+            ++it;
+
+            std::size_t bucket_count = x.bucket_count();
+            x.insert(it, v.end());
+            BOOST_TEST(bucket_count == x.bucket_count());
+            tracker.compare(x);
+        }
+    }
+}
+
+template <class X>
+void reserve_test2(X* = 0,
+    test::random_generator generator = test::default_generator)
+{
+    for (int random_mlf = 0; random_mlf < 2; ++random_mlf)
+    {
+        for (int i = 0; i < 2000; i += i < 50 ? 1 : 13)
+        {
+            test::random_values<X> v(i, generator);
+
+            test::ordered<X> tracker;
+            tracker.insert_range(v.begin(), v.end());
+
+            X x;
+            x.max_load_factor(random_mlf ?
+                static_cast<float>(std::rand() % 1000) / 500.0f + 0.5f : 1.0f);
+
+            x.reserve(i);
+            std::size_t bucket_count = x.bucket_count();
+
+            for (typename test::random_values<X>::iterator it = v.begin();
+                    it != v.end(); ++it)
+            {
+                x.insert(*it);
+            }
+
+            BOOST_TEST(bucket_count == x.bucket_count());
+            tracker.compare(x);
+        }
+    }
+}
+
 boost::unordered_set<int>* int_set_ptr;
 boost::unordered_multiset<int>* int_multiset_ptr;
 boost::unordered_map<int, int>* int_map_ptr;
@@ -117,6 +186,12 @@ UNORDERED_TEST(rehash_empty_test3,
 UNORDERED_TEST(rehash_test1,
     ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
 )
+UNORDERED_TEST(reserve_test1,
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
+)
+UNORDERED_TEST(reserve_test2,
+    ((int_set_ptr)(int_multiset_ptr)(int_map_ptr)(int_multimap_ptr))
+)
 
 }
 

test/unordered/swap_tests.cpp

@@ -25,7 +25,7 @@
 namespace swap_tests
 {
 
-test::seed_t seed(783472);
+test::seed_t initialize_seed(783472);
 
 template <class X>
 void swap_test_impl(X& x1, X& x2)