[DEV] add v1.76.0

libs/unordered/test/exception/assign_exception_tests.cpp

@@ -54,9 +54,9 @@ template <class T> struct assign_base : public test::exception_base
   test::random_values<T> x_values, y_values;
   T x, y;
 
-  typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
-  typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
-  typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+  typedef typename T::hasher hasher;
+  typedef typename T::key_equal key_equal;
+  typedef typename T::allocator_type allocator_type;
 
   assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
       : x_values(), y_values(),

libs/unordered/test/exception/constructor_exception_tests.cpp

@@ -172,9 +172,9 @@ template <class T> struct input_range_construct_test : public range<T>, objects
 
   void run() const
   {
-    BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-      begin = this->values.begin(),
-      end = this->values.end();
+    typename test::random_values<T>::const_iterator begin =
+                                                      this->values.begin(),
+                                                    end = this->values.end();
     T x(test::input_iterator(begin), test::input_iterator(end), 0, hash,
       equal_to, allocator);
 

libs/unordered/test/exception/erase_exception_tests.cpp

@@ -38,8 +38,7 @@ template <class T> struct erase_by_key_test1 : public erase_test_base<T>
 {
   void run(T& x) const
   {
-    typedef BOOST_DEDUCED_TYPENAME test::random_values<T>::const_iterator
-      iterator;
+    typedef typename test::random_values<T>::const_iterator iterator;
 
     for (iterator it = this->values.begin(), end = this->values.end();
          it != end; ++it) {

libs/unordered/test/exception/insert_exception_tests.cpp

@@ -18,7 +18,7 @@ test::seed_t initialize_seed(747373);
 template <typename T> void rehash_prep(T& x)
 {
   using namespace std;
-  typedef BOOST_DEDUCED_TYPENAME T::size_type size_type;
+  typedef typename T::size_type size_type;
 
   x.max_load_factor(0.25);
   size_type bucket_count = x.bucket_count();
@@ -146,23 +146,24 @@ struct insert_lvalue_end_type : inserter_base
   }
 } insert_lvalue_end;
 
+template <typename T> struct insert_lvalue_pos_type_impl : inserter_base
+{
+  typename T::iterator pos;
+
+  insert_lvalue_pos_type_impl(T& x) : pos(x.begin()) {}
+
+  template <typename Iterator> void operator()(T& x, Iterator it)
+  {
+    pos = get_iterator(x.insert(pos, *it));
+  }
+};
+
 struct insert_lvalue_pos_type
 {
-  template <typename T> struct impl : inserter_base
+  template <typename T>
+  friend insert_lvalue_pos_type_impl<T> generate(insert_lvalue_pos_type, T& x)
   {
-    typename T::iterator pos;
-
-    impl(T& x) : pos(x.begin()) {}
-
-    template <typename Iterator> void operator()(T& x, Iterator it)
-    {
-      pos = get_iterator(x.insert(pos, *it));
-    }
-  };
-
-  template <typename T> friend impl<T> generate(insert_lvalue_pos_type, T& x)
-  {
-    return impl<T>(x);
+    return insert_lvalue_pos_type_impl<T>(x);
   }
 } insert_lvalue_pos;
 
@@ -198,23 +199,24 @@ struct emplace_lvalue_end_type : inserter_base
   }
 } emplace_lvalue_end;
 
+template <typename T> struct emplace_lvalue_pos_type_impl : inserter_base
+{
+  typename T::iterator pos;
+
+  emplace_lvalue_pos_type_impl(T& x) : pos(x.begin()) {}
+
+  template <typename Iterator> void operator()(T& x, Iterator it)
+  {
+    pos = get_iterator(x.emplace_hint(pos, *it));
+  }
+};
+
 struct emplace_lvalue_pos_type
 {
-  template <typename T> struct impl : inserter_base
+  template <typename T>
+  friend emplace_lvalue_pos_type_impl<T> generate(emplace_lvalue_pos_type, T& x)
   {
-    typename T::iterator pos;
-
-    impl(T& x) : pos(x.begin()) {}
-
-    template <typename Iterator> void operator()(T& x, Iterator it)
-    {
-      pos = get_iterator(x.emplace_hint(pos, *it));
-    }
-  };
-
-  template <typename T> friend impl<T> generate(emplace_lvalue_pos_type, T& x)
-  {
-    return impl<T>(x);
+    return emplace_lvalue_pos_type_impl<T>(x);
   }
 } emplace_lvalue_pos;
 

libs/unordered/test/exception/merge_exception_tests.cpp

@@ -1,3 +1,8 @@
+
+// Copyright 2017-2018 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)
+
 #include "../helpers/exception_test.hpp"
 #include "../helpers/invariants.hpp"
 #include "../helpers/metafunctions.hpp"

libs/unordered/test/exception/move_assign_exception_tests.cpp

@@ -21,9 +21,9 @@ template <class T> struct move_assign_base : public test::exception_base
   test::random_values<T> x_values, y_values;
   T x, y;
 
-  typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
-  typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
-  typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+  typedef typename T::hasher hasher;
+  typedef typename T::key_equal key_equal;
+  typedef typename T::allocator_type allocator_type;
 
   move_assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
       : x_values(), y_values(),

libs/unordered/test/exception/swap_exception_tests.cpp

@@ -60,9 +60,9 @@ template <class T> struct swap_base : public test::exception_base
   const test::random_values<T> x_values, y_values;
   const T initial_x, initial_y;
 
-  typedef BOOST_DEDUCED_TYPENAME T::hasher hasher;
-  typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal;
-  typedef BOOST_DEDUCED_TYPENAME T::allocator_type allocator_type;
+  typedef typename T::hasher hasher;
+  typedef typename T::key_equal key_equal;
+  typedef typename T::allocator_type allocator_type;
 
   swap_base(unsigned int count1, unsigned int count2, int tag1, int tag2)
       : x_values(count1, test::limited_range),
@@ -90,7 +90,7 @@ template <class T> struct swap_base : public test::exception_base
   {
     try {
       d.x.swap(d.y);
-    } catch (std::runtime_error) {
+    } catch (std::runtime_error&) {
     }
 
     DISABLE_EXCEPTIONS;