Ticket #3996: ptr_container_propagate_noncopyable_for_foreach.patch

boost/ptr_container/detail/reversible_ptr_container.hpp

@@ -35 +35 @@
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_pointer.hpp>
 #include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/not.hpp>
+#include <boost/noncopyable.hpp>
 #include <boost/swap.hpp>
 #include <typeinfo>
 #include <memory>
@@ -48 +53 @@
 namespace boost
 {
 
+// minimum declaration required by propagate_noncopyable_for_foreach
+namespace foreach { template< class T > struct is_noncopyable; }
+
 namespace ptr_container_detail
 {
     template< class Container >
@@ -93 +101 @@
     struct associative_container_tag {};
     struct ordered_associative_container_tag : associative_container_tag {};
     struct unordered_associative_container_tag : associative_container_tag {};
-    
 
+    // Mark the ptr_container with boost::noncopyable as appropreate to
+    // enable use of BOOST_FOREACH over const reference of ptr_container
+    // of which value_type is noncopyable.
+    // See: http://www.boost.org/doc/html/foreach/extensibility.html#id862475
+    struct copyable {}; // dummy
+    template<typename ValueType, typename CloneAllocator>
+    struct propagate_noncopyable_for_foreach
+      : mpl::if_<
+          mpl::and_<
+            mpl::not_<boost::is_same<CloneAllocator, view_clone_allocator> >,
+            boost::foreach::is_noncopyable<ValueType>
+          >,
+          boost::noncopyable,
+          copyable
+        >::type {};
     
     template
     < 
         class Config, 
         class CloneAllocator
     >
-    class reversible_ptr_container : CloneAllocator
+    class reversible_ptr_container : CloneAllocator,
+        private propagate_noncopyable_for_foreach<
+            BOOST_DEDUCED_TYPENAME Config::value_type, CloneAllocator>
     {
     private:
         BOOST_STATIC_CONSTANT( bool, allow_null = Config::allow_null );

libs/ptr_container/test/foreach_noncopyable_detection.cpp

@@ +1 @@
+#include "boost/ptr_container/ptr_vector.hpp"
+#include "boost/ptr_container/ptr_map.hpp"
+#include "boost/ptr_container/ptr_set.hpp"
+#include "boost/foreach.hpp"
+
+struct normal {};
+bool operator < (normal const&, normal const&);
+
+struct abstract { virtual void f() const = 0; };
+bool operator < (abstract const&, abstract const&);
+
+struct noncopyable : boost::noncopyable {};
+bool operator < (noncopyable const&, noncopyable const&);
+
+
+using boost::foreach::is_noncopyable;
+
+template<typename T, typename CloneAllocator, bool ExpectedNoncopyable>
+struct test_noncopyable
+{
+    typedef boost::ptr_vector<T, CloneAllocator> sequence;
+    BOOST_STATIC_ASSERT(is_noncopyable<sequence>::value == ExpectedNoncopyable);
+
+    typedef boost::ptr_set<T, std::less<T>, CloneAllocator> set;
+    BOOST_STATIC_ASSERT(is_noncopyable<set>::value == ExpectedNoncopyable);
+
+    typedef boost::ptr_map<normal, T, std::less<normal>, CloneAllocator> map;
+    BOOST_STATIC_ASSERT(is_noncopyable<map>::value == ExpectedNoncopyable);
+};
+
+
+test_noncopyable<normal, boost::heap_clone_allocator, false>
+normal_container_should_be_copyable;
+
+test_noncopyable<normal, boost::view_clone_allocator, false>
+normal_view_should_be_copyable;
+
+test_noncopyable<abstract, boost::heap_clone_allocator, true>
+abstract_container_should_be_noncopyable;
+
+test_noncopyable<abstract, boost::view_clone_allocator, false>
+abstract_view_should_be_copyable;
+
+test_noncopyable<noncopyable, boost::heap_clone_allocator, true>
+noncopyable_container_should_be_noncopyable;
+
+test_noncopyable<noncopyable, boost::view_clone_allocator, false>
+noncopyable_view_should_be_copyable;