Remove BOOST_COPYABLE_AND_MOVABLE

include/boost/unordered/unordered_map.hpp

@@ -41,9 +41,6 @@ namespace boost {
   namespace unordered {
     template <class K, class T, class H, class P, class A> class unordered_map
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-      BOOST_COPYABLE_AND_MOVABLE(unordered_map)
-#endif
       template <typename, typename, typename, typename, typename>
       friend class unordered_multimap;
 
@@ -689,9 +686,6 @@ namespace boost {
     template <class K, class T, class H, class P, class A>
     class unordered_multimap
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-      BOOST_COPYABLE_AND_MOVABLE(unordered_multimap)
-#endif
       template <typename, typename, typename, typename, typename>
       friend class unordered_map;
 
@@ -2175,8 +2169,6 @@ namespace boost {
 
     template <typename N, class K, class T, class A> class node_handle_map
     {
-      BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_map)
-
       template <typename Types> friend struct ::boost::unordered::detail::table;
       template <class K2, class T2, class H2, class P2, class A2>
       friend class boost::unordered::unordered_map;
@@ -2208,6 +2200,8 @@ namespace boost {
 
     public:
       constexpr node_handle_map() noexcept : ptr_(), alloc_() {}
+      node_handle_map(node_handle_map const&) = delete;
+      node_handle_map& operator=(node_handle_map const&) = delete;
 
       ~node_handle_map()
       {
@@ -2296,19 +2290,14 @@ namespace boost {
 
     template <class Iter, class NodeType> struct insert_return_type_map
     {
-    private:
-      BOOST_MOVABLE_BUT_NOT_COPYABLE(insert_return_type_map)
-
-      // typedef typename boost::allocator_rebind<A,
-      //   std::pair<K const, T> >::type value_allocator;
-      // typedef N node_;
-
     public:
       Iter position;
       bool inserted;
       NodeType node;
 
       insert_return_type_map() : position(), inserted(false), node() {}
+      insert_return_type_map(insert_return_type_map const&) = delete;
+      insert_return_type_map& operator=(insert_return_type_map const&) = delete;
 
       insert_return_type_map(insert_return_type_map&& x) noexcept
           : position(x.position),

include/boost/unordered/unordered_set.hpp

@@ -40,9 +40,6 @@ namespace boost {
   namespace unordered {
     template <class T, class H, class P, class A> class unordered_set
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-      BOOST_COPYABLE_AND_MOVABLE(unordered_set)
-#endif
       template <typename, typename, typename, typename>
       friend class unordered_multiset;
 
@@ -536,9 +533,6 @@ namespace boost {
 
     template <class T, class H, class P, class A> class unordered_multiset
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-      BOOST_COPYABLE_AND_MOVABLE(unordered_multiset)
-#endif
       template <typename, typename, typename, typename>
       friend class unordered_set;
 
@@ -1803,8 +1797,6 @@ namespace boost {
 
     template <typename N, typename T, typename A> class node_handle_set
     {
-      BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_set)
-
       template <typename Types> friend struct ::boost::unordered::detail::table;
       template <class T2, class H2, class P2, class A2>
       friend class unordered_set;
@@ -1838,6 +1830,8 @@ namespace boost {
 
     public:
       constexpr node_handle_set() noexcept : ptr_(), has_alloc_(false) {}
+      node_handle_set(node_handle_set const&) = delete;
+      node_handle_set& operator=(node_handle_set const&) = delete;
 
       ~node_handle_set()
       {
@@ -1918,19 +1912,14 @@ namespace boost {
 
     template <class Iter, class NodeType> struct insert_return_type_set
     {
-    private:
-      BOOST_MOVABLE_BUT_NOT_COPYABLE(insert_return_type_set)
-
-      // typedef typename boost::unordered::detail::rebind_wrap<A, T>::type
-      //   value_allocator;
-      // typedef N node_;
-
     public:
       Iter position;
       bool inserted;
       NodeType node;
 
       insert_return_type_set() : position(), inserted(false), node() {}
+      insert_return_type_set(insert_return_type_set const&) = delete;
+      insert_return_type_set& operator=(insert_return_type_set const&) = delete;
 
       insert_return_type_set(insert_return_type_set&& x) noexcept
           : position(x.position),

test/objects/test.hpp

@@ -96,7 +96,6 @@ namespace test {
     friend class less;
     int tag1_, tag2_;
 
-    BOOST_COPYABLE_AND_MOVABLE(movable)
   public:
     explicit movable(int t1 = 0, int t2 = 0) : tag1_(t1), tag2_(t2) {}
 

test/unordered/noexcept_tests.cpp

@@ -57,8 +57,6 @@ namespace noexcept_tests {
     bool nothrow_swap>
   class hash_nothrow : boost::hash<int>
   {
-    BOOST_COPYABLE_AND_MOVABLE(hash_nothrow)
-
     typedef boost::hash<int> base;
 
   public:
@@ -105,8 +103,6 @@ namespace noexcept_tests {
     bool nothrow_swap>
   class equal_to_nothrow
   {
-    BOOST_COPYABLE_AND_MOVABLE(equal_to_nothrow)
-
     typedef boost::hash<int> base;
 
   public:
@@ -356,7 +352,6 @@ namespace noexcept_tests {
 
 template <class T> class allocator1
 {
-  BOOST_COPYABLE_AND_MOVABLE(allocator1)
   allocator1 operator=(allocator1 const&);
   allocator1 operator=(allocator1&&);
 
@@ -382,7 +377,6 @@ public:
 
 template <class T> class allocator2
 {
-  BOOST_COPYABLE_AND_MOVABLE(allocator2)
   allocator2 operator=(allocator2 const&);
 
 public:

test/unordered/unnecessary_copy_tests.cpp

@@ -15,8 +15,6 @@
 namespace unnecessary_copy_tests {
   struct count_copies
   {
-  private:
-    BOOST_COPYABLE_AND_MOVABLE(count_copies)
   public:
     static int copies;
     static int moves;