[Boost-commit] svn:boost r55317 - in sandbox/fmhess: boost/generic_ptr libs/generic_ptr/test

Subject: [Boost-commit] svn:boost r55317 - in sandbox/fmhess: boost/generic_ptr libs/generic_ptr/test
From: fmhess_at_[hidden]
Date: 2009-07-31 15:04:14

Author: fmhess
Date: 2009-07-31 15:04:13 EDT (Fri, 31 Jul 2009)
New Revision: 55317
URL: http://svn.boost.org/trac/boost/changeset/55317

Log:
Made cloning always apply new_clone to all wrapping generic
pointer types (cloning_monitor_test passes now).  Added
new_clone overload for monitor, which locks its mutex before
making clone.

Text files modified: 
   sandbox/fmhess/boost/generic_ptr/cloning.hpp                  |   169 ++++++++++++++++++++++++--------------- 
   sandbox/fmhess/boost/generic_ptr/monitor.hpp                  |    11 ++                                      
   sandbox/fmhess/libs/generic_ptr/test/Jamfile.v2               |     2                                         
   sandbox/fmhess/libs/generic_ptr/test/cloning_monitor_test.cpp |     3                                         
   4 files changed, 116 insertions(+), 69 deletions(-)

Modified: sandbox/fmhess/boost/generic_ptr/cloning.hpp
==============================================================================
--- sandbox/fmhess/boost/generic_ptr/cloning.hpp	(original)
+++ sandbox/fmhess/boost/generic_ptr/cloning.hpp	2009-07-31 15:04:13 EDT (Fri, 31 Jul 2009)
@@ -41,40 +41,25 @@
     {
       return GenericPointer(new_clone(get_pointer(p)));
     }
+    //FIXME: add similar delete_clone functions
 
     namespace detail
     {
+      template<typename GenericVoidPointer>
       class clone_factory_impl_base
       {
       public:
         virtual ~clone_factory_impl_base() {}
-        //FIXME: this isn't adequate.  We need to return a generic pointer to void instead
-        virtual void * get_pointer() = 0;
+        virtual GenericVoidPointer get_pointer() = 0;
         virtual clone_factory_impl_base* make_clone() = 0;
       };
 
-      template<typename T>
-      class clone_factory_impl: public clone_factory_impl_base
-      {
-      public:
-        explicit clone_factory_impl(T *p): px(p)
-        {}
-        ~clone_factory_impl()
-        {
-          delete_clone(px);
-        }
-        virtual void * get_pointer() { return px; }
-        virtual clone_factory_impl* make_clone()
-        {
-          if(px == 0) return new clone_factory_impl(0);
-          return new clone_factory_impl(new_clone(px));
-        }
-      private:
-        T * px;
-      };
-
       template<typename GenericPointer, typename Deleter, typename Cloner>
-      class clone_factory_pdc_impl: public clone_factory_impl_base
+      class clone_factory_pdc_impl: public
+        clone_factory_impl_base
+        <
+          typename rebind<GenericPointer, void>::other
+        >
       {
       public:
         clone_factory_pdc_impl(GenericPointer p, Deleter d, Cloner c): px(p), deleter(d), cloner(c)
@@ -83,7 +68,11 @@
         {
           deleter(px);
         }
-        virtual void * get_pointer() { return get_plain_old_pointer(px); }
+        virtual typename rebind<GenericPointer, void>::other get_pointer()
+        {
+          //FIXME: remove const from px's value_type
+          return px;
+        }
         virtual clone_factory_pdc_impl* make_clone()
         {
           return new clone_factory_pdc_impl(cloner(px), deleter, cloner);
@@ -94,14 +83,12 @@
         Cloner cloner;
       };
 
+      template<typename GenericVoidPointer>
       class clone_factory
       {
       public:
         clone_factory(): _impl()
         {}
-        template<typename T>
-        explicit clone_factory(T * p): _impl(new clone_factory_impl<T>(p))
-        {}
         template<typename T, typename Deleter, typename Cloner>
         clone_factory(T p, Deleter d, Cloner c): _impl(new clone_factory_pdc_impl<T, Deleter, Cloner>(p, d, c))
         {}
@@ -113,9 +100,9 @@
           swap(other);
         }
 #endif
-        void * get_pointer()
+        GenericVoidPointer get_pointer()
         {
-          if(_impl.get() == 0) return 0;
+          if(_impl.get() == 0) return GenericVoidPointer();
           return _impl->get_pointer();
         }
         void swap(clone_factory &other)
@@ -125,9 +112,10 @@
       private:
         clone_factory& operator=(const clone_factory &);  // could be implemented and made public if we needed it
 
-        scoped_ptr<clone_factory_impl_base> _impl;
+        scoped_ptr<clone_factory_impl_base<GenericVoidPointer> > _impl;
       };
-      void swap(clone_factory &a, clone_factory &b)
+      template<typename T>
+      void swap(clone_factory<T> &a, clone_factory<T> &b)
       {
         a.swap(b);
       }
@@ -160,6 +148,7 @@
       typedef cloning this_type; // for detail/operator_bool.hpp
       template<typename U>
       friend class cloning;
+      typedef detail::clone_factory<typename generic_ptr::rebind<T, void>::other> clone_factory_type;
     public:
       typedef typename pointer_traits<T>::value_type value_type;
       typedef T pointer;
@@ -171,104 +160,150 @@
         typedef cloning<typename generic_ptr::rebind<pointer, ValueType>::other> other;
       };
 
-      cloning(): _cloner(), px()
+      cloning(): _clone_factory(), px()
       {}
       template<typename U>
-      cloning( U p ): _cloner(get_plain_old_pointer(p)), px( p )
+      cloning( U p ):
+        _clone_factory
+        (
+          typename generic_ptr::rebind<T, typename pointer_traits<U>::value_type>::other(p),
+          default_cloning_deleter(),
+          default_cloner()
+        ),
+        px
+        (
+          static_pointer_cast
+          <
+            typename pointer_traits<U>::value_type
+          >(_clone_factory.get_pointer())
+        )
       {}
-      template<typename U, typename Deleter, typename Cloner = default_cloner>
-      cloning(U p, Deleter d, Cloner c = default_cloner()): _cloner(p, d, c), px( p )
+      template<typename U, typename Deleter>
+      cloning(U p, Deleter d):
+        _clone_factory
+        (
+          typename generic_ptr::rebind<T, typename pointer_traits<U>::value_type>::other(p),
+          d,
+          default_cloner()
+        ),
+        px
+        (
+          static_pointer_cast
+          <
+            typename pointer_traits<U>::value_type
+          >(_clone_factory.get_pointer())
+        )
+      {}
+      template<typename U, typename Deleter, typename Cloner>
+      cloning(U p, Deleter d, Cloner c):
+        _clone_factory
+        (
+          typename generic_ptr::rebind<T, typename pointer_traits<U>::value_type>::other(p),
+          d,
+          c
+        ),
+        px
+        (
+          static_pointer_cast
+          <
+            typename pointer_traits<U>::value_type
+          >(_clone_factory.get_pointer())
+        )
       {}
       cloning(const cloning & other):
-        _cloner(other._cloner),
+        _clone_factory(other._clone_factory),
         px
         (
-          static_cast<value_type *>(_cloner.get_pointer())
+          static_pointer_cast<value_type>(_clone_factory.get_pointer())
         )
       {}
       template<typename U>
       cloning(const cloning<U> & other):
-        _cloner(other._cloner),
+        _clone_factory(other._clone_factory),
         px
         (
-          static_cast
+          static_pointer_cast
           <
-            typename pointer_traits<U>::value_type *
-          >(_cloner.get_pointer())
+            typename pointer_traits<U>::value_type
+          >(_clone_factory.get_pointer())
         )
       {}
 
       // casts
       template<typename U>
       cloning(const cloning<U> & other, detail::static_cast_tag):
-        _cloner(other._cloner),
+        _clone_factory(other._clone_factory),
         px
         (
-          static_cast
+          static_pointer_cast
           <
-            value_type *
+            value_type
           >
           (
-            static_cast
+            static_pointer_cast
             <
-              typename pointer_traits<U>::value_type *
-            >(_cloner.get_pointer())
+              typename pointer_traits<U>::value_type
+            >(_clone_factory.get_pointer())
           )
         )
       {}
       template<typename U>
       cloning(const cloning<U> & other, detail::const_cast_tag):
-        _cloner(other._cloner),
+        _clone_factory(other._clone_factory),
         px
         (
-          const_cast
+          const_pointer_cast
           <
-            value_type *
+            value_type
           >
           (
-            static_cast
+            static_pointer_cast
             <
-              typename pointer_traits<U>::value_type *
-            >(_cloner.get_pointer())
+              typename pointer_traits<U>::value_type
+            >(_clone_factory.get_pointer())
           )
         )
       {}
       template<typename U>
       cloning(const cloning<U> & other, detail::dynamic_cast_tag):
-        _cloner(other._cloner),
+        _clone_factory(other._clone_factory),
         px
         (
-          dynamic_cast
+          dynamic_pointer_cast
           <
-            value_type *
+            value_type
           >
           (
-            static_cast
+            static_pointer_cast
             <
-              typename pointer_traits<U>::value_type *
-            >(_cloner.get_pointer())
+              typename pointer_traits<U>::value_type
+            >(_clone_factory.get_pointer())
           )
         )
       {
-        // reset _cloner if dynamic cast failed
+        // reset _clone_factory if dynamic cast failed
         if(get_plain_old_pointer(px) == 0)
         {
-          detail::clone_factory().swap(_cloner);
+          clone_factory_type().swap(_clone_factory);
         }
       }
 
 #ifndef BOOST_NO_RVALUE_REFERENCES
-      cloning(cloning && other): _cloner(std::move(other._cloner)), px(std::move(other.px))
-      {}
+      cloning(cloning && other): _clone_factory(std::move(other._clone_factory)), px(std::move(other.px))
+      {
+        detail::set_plain_old_pointer_to_null(other.px);
+      }
       template<typename U>
-      cloning(cloning<U> && other): _cloner(std::move(other._cloner)), px(std::move(other.px))
-      {}
+      cloning(cloning<U> && other): _clone_factory(std::move(other._clone_factory)), px(std::move(other.px))
+      {
+        detail::set_plain_old_pointer_to_null(other.px);
+      }
 #endif
 
       void swap(cloning & other)
       {
         boost::swap(px, other.px);
-        boost::swap(_cloner, other._cloner);
+        boost::swap(_clone_factory, other._clone_factory);
       }
 
       cloning & operator=(const cloning & other)
@@ -321,7 +356,7 @@
       }
 
     private:
-      detail::clone_factory _cloner;
+      clone_factory_type _clone_factory;
       pointer px;
     };
 

Modified: sandbox/fmhess/boost/generic_ptr/monitor.hpp
==============================================================================
--- sandbox/fmhess/boost/generic_ptr/monitor.hpp	(original)
+++ sandbox/fmhess/boost/generic_ptr/monitor.hpp	2009-07-31 15:04:13 EDT (Fri, 31 Jul 2009)
@@ -212,6 +212,17 @@
     {
       return std::less<typename monitor<T, Mutex>::pointer>()(a.get(), b.get());
     }
+
+    // new_clone overload for safe (mutex locked) use with generic_ptr::cloning
+    template<typename GenericPointer, typename Mutex>
+    monitor<GenericPointer, Mutex> new_clone(const monitor<GenericPointer, Mutex> &p)
+    {
+      if(get_plain_old_pointer(p) == 0) return p;
+      monitor_unique_lock<monitor<GenericPointer, Mutex> > lock(p);
+      using boost::generic_ptr::new_clone;
+      return monitor<GenericPointer, Mutex>(new_clone(p.get()));
+    }
+    // FIXME: add similar delete_clone overload
   } // namespace generic_ptr
 } // namespace boost
 

Modified: sandbox/fmhess/libs/generic_ptr/test/Jamfile.v2
==============================================================================
--- sandbox/fmhess/libs/generic_ptr/test/Jamfile.v2	(original)
+++ sandbox/fmhess/libs/generic_ptr/test/Jamfile.v2	2009-07-31 15:04:13 EDT (Fri, 31 Jul 2009)
@@ -23,7 +23,7 @@
     test-suite "generic_ptr"
         : [ thread-run basic_generic_pointer_test.cpp ]
           [ run cloning_test.cpp ]
-          [ run cloning_monitor_test.cpp ]
+          [ thread-run cloning_monitor_test.cpp ]
           [ run throwing_test.cpp ]
         ;
 }

Modified: sandbox/fmhess/libs/generic_ptr/test/cloning_monitor_test.cpp
==============================================================================
--- sandbox/fmhess/libs/generic_ptr/test/cloning_monitor_test.cpp	(original)
+++ sandbox/fmhess/libs/generic_ptr/test/cloning_monitor_test.cpp	2009-07-31 15:04:13 EDT (Fri, 31 Jul 2009)
@@ -42,7 +42,8 @@
 
 void clone_test()
 {
-  typedef boost::generic_ptr::cloning<boost::generic_ptr::monitor<int*, event_counting_mutex> > cloning_monitor_type;
+  typedef boost::generic_ptr::monitor<int*, event_counting_mutex> monitor_type;
+  typedef boost::generic_ptr::cloning<monitor_type> cloning_monitor_type;
   cloning_monitor_type p0(new int());
   BOOST_TEST(p0.get().get_mutex_ref().lock_count == 0);
   BOOST_TEST(p0.get().get_mutex_ref().unlock_count == 0);