[Boost-commit] svn:boost r50938 - in sandbox/thread_safe_signals/trunk: boost/signals2 libs/signals2/test

Subject: [Boost-commit] svn:boost r50938 - in sandbox/thread_safe_signals/trunk: boost/signals2 libs/signals2/test
From: fmhess_at_[hidden]
Date: 2009-01-31 20:12:04

Author: fmhess
Date: 2009-01-31 20:12:03 EST (Sat, 31 Jan 2009)
New Revision: 50938
URL: http://svn.boost.org/trac/boost/changeset/50938

Log:
Reworked deconstruct<>() so it operates non-intrusively via
argument-dependent lookup instead of needing postconstructible
and predestructible base classes.  Also added support for
passing arguments to postconstructors.

Text files modified: 
   sandbox/thread_safe_signals/trunk/boost/signals2/deconstruct.hpp          |   174 +++++++++++++++++++++++++++++++++------ 
   sandbox/thread_safe_signals/trunk/boost/signals2/deconstruct_ptr.hpp      |     2                                         
   sandbox/thread_safe_signals/trunk/boost/signals2/postconstructible.hpp    |    38 +++++--                                 
   sandbox/thread_safe_signals/trunk/boost/signals2/predestructible.hpp      |    26 ++++-                                   
   sandbox/thread_safe_signals/trunk/libs/signals2/test/deconstruct_test.cpp |    64 ++++++++++++++                          
   5 files changed, 254 insertions(+), 50 deletions(-)

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/deconstruct.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/deconstruct.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/deconstruct.hpp	2009-01-31 20:12:03 EST (Sat, 31 Jan 2009)
@@ -2,6 +2,15 @@
 #define BOOST_SIGNALS2_DECONSTRUCT_HPP
 
 //  deconstruct.hpp
+//
+// A factory function for creating a shared_ptr which creates
+// an object and its owning shared_ptr with one allocation, similar
+// to make_shared<T>().  It also supports postconstructors
+// and predestructors through unqualified calls of adl_postconstruct() and
+// adl_predestruct, relying on argument-dependent
+// lookup to find the appropriate postconstructor or predestructor.
+// Passing arguments to postconstructors is also supported.
+//
 //  based on make_shared.hpp and make_shared_access patch from Michael Marcin
 //
 //  Copyright (c) 2007, 2008 Peter Dimov
@@ -18,8 +27,9 @@
 #include <boost/config.hpp>
 #include <boost/shared_ptr.hpp>
 #include <boost/signals2/deconstruct_ptr.hpp>
-#include <boost/type_traits/type_with_alignment.hpp>
 #include <boost/type_traits/alignment_of.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/type_traits/type_with_alignment.hpp>
 #include <cstddef>
 #include <new>
 
@@ -31,6 +41,115 @@
 
 namespace detail
 {
+  template< class T > T forward( T t )
+  {
+      return t;
+  }
+  inline void adl_predestruct(...) {}
+} // namespace detail
+
+template<typename T>
+    class postconstructor_invoker
+{
+public:
+    postconstructor_invoker(const shared_ptr<T> & sp):
+        _sp(sp)
+    {}
+    operator shared_ptr<T> () const
+    {
+        return postconstruct();
+    }
+    const shared_ptr<T>& postconstruct() const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()));
+        return _sp;
+    }
+#if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
+    template<class T, class... Args>
+      const shared_ptr<T>& postconstruct(Args && ... args)
+    {
+      adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+        detail::forward<Args>(args)...);
+    }
+#else
+    template<typename A1>
+      const shared_ptr<T>& postconstruct(const A1 &a1) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1);
+        return _sp;
+    }
+    template<typename A1, typename A2>
+      const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1, a2);
+        return _sp;
+    }
+    template<typename A1, typename A2, typename A3>
+      const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1, a2, a3);
+        return _sp;
+    }
+    template<typename A1, typename A2, typename A3, typename A4>
+      const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1, a2, a3, a4);
+        return _sp;
+    }
+    template<typename A1, typename A2, typename A3, typename A4, typename A5>
+      const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1, a2, a3, a4, a5);
+        return _sp;
+    }
+    template<typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6>
+      const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
+      const A6 &a6) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1, a2, a3, a4, a5, a6);
+        return _sp;
+    }
+    template<typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7>
+      const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
+      const A6 &a6, const A7 &a7) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1, a2, a3, a4, a5, a6, a7);
+        return _sp;
+    }
+    template<typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8>
+      const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
+      const A6 &a6, const A7 &a7, const A8 &a8) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1, a2, a3, a4, a5, a6, a7, a8);
+        return _sp;
+    }
+    template<typename A1, typename A2, typename A3, typename A4, typename A5,
+      typename A6, typename A7, typename A8, typename A9>
+      const shared_ptr<T>& postconstruct(const A1 &a1, const A2 &a2, const A3 &a3, const A4 &a4, const A5 &a5,
+      const A6 &a6, const A7 &a7, const A8 &a8, const A9 &a9) const
+    {
+        adl_postconstruct(_sp, const_cast<typename boost::remove_const<T>::type *>(_sp.get()),
+          a1, a2, a3, a4, a5, a6, a7, a8, a9);
+        return _sp;
+    }
+#endif // else defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
+private:
+    shared_ptr<T> _sp;
+};
+
+namespace detail
+{
 
 template< std::size_t N, std::size_t A > struct sp_aligned_storage
 {
@@ -57,7 +176,8 @@
         if( initialized_ )
         {
             T* p = reinterpret_cast< T* >( storage_.data_ );
-            detail::do_predestruct(p);
+            using boost::signals2::detail::adl_predestruct;
+            adl_predestruct(const_cast<typename boost::remove_const<T>::type *>(p));
             p->~T();
             initialized_ = false;
         }
@@ -96,17 +216,12 @@
     }
 };
 
-template< class T > T forward( T t )
-{
-    return t;
-}
-
 class deconstruct_access
 {
 public:
 
     template< class T >
-    static boost::shared_ptr< T > deconstruct()
+    static postconstructor_invoker<T> deconstruct()
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -117,9 +232,8 @@
         new( pv ) T();
         pd->set_initialized();
 
-        boost::shared_ptr< T > retval( pt, static_cast< T* >( pv ) );
-        detail::do_postconstruct(retval.get());
-        return retval;
+        boost::shared_ptr< T > sp( pt, static_cast< T* >( pv ) );
+        return postconstructor_invoker<T>(sp);
     }
 
 #if defined( BOOST_HAS_VARIADIC_TMPL ) && defined( BOOST_HAS_RVALUE_REFS )
@@ -127,7 +241,7 @@
     // Variadic templates, rvalue reference
 
     template< class T, class... Args >
-    static boost::shared_ptr< T > deconstruct( Args && ... args )
+    static postconstructor_invoker<T> deconstruct( Args && ... args )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -146,7 +260,7 @@
 #else
 
     template< class T, class A1 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -163,7 +277,7 @@
     }
 
     template< class T, class A1, class A2 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -180,7 +294,7 @@
     }
 
     template< class T, class A1, class A2, class A3 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -197,7 +311,7 @@
     }
 
     template< class T, class A1, class A2, class A3, class A4 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -214,7 +328,7 @@
     }
 
     template< class T, class A1, class A2, class A3, class A4, class A5 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -231,7 +345,7 @@
     }
 
     template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -248,7 +362,7 @@
     }
 
     template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -265,7 +379,7 @@
     }
 
     template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -282,7 +396,7 @@
     }
 
     template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-    static boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+    static postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
     {
         boost::shared_ptr< T > pt( static_cast< T* >( 0 ), detail::deconstruct_deleter< T >() );
 
@@ -325,55 +439,55 @@
 // C++03 version
 
 template< class T, class A1 >
-boost::shared_ptr< T > deconstruct( A1 const & a1 )
+postconstructor_invoker<T> deconstruct( A1 const & a1 )
 {
         return detail::deconstruct_access::deconstruct<T>(a1);
 }
 
 template< class T, class A1, class A2 >
-boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2 )
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2 )
 {
    return detail::deconstruct_access::deconstruct<T>(a1,a2);
 }
 
 template< class T, class A1, class A2, class A3 >
-boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3 )
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3 )
 {
         return detail::deconstruct_access::deconstruct<T>(a1,a2,a3);
 }
 
 template< class T, class A1, class A2, class A3, class A4 >
-boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4 )
 {
     return detail::deconstruct_access::deconstruct<T>(a1,a2,a3,a4);
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5 >
-boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5 )
 {
     return detail::deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5);
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6 >
-boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6 )
 {
     return detail::deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6);
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7 >
-boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7 )
 {
     return detail::deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7);
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8 >
-boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8 )
 {
     return detail::deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7,a8);
 }
 
 template< class T, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9 >
-boost::shared_ptr< T > deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
+postconstructor_invoker<T> deconstruct( A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9 )
 {
     return detail::deconstruct_access::deconstruct<T>(a1,a2,a3,a4,a5,a6,a7,a8,a9);
 }

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/deconstruct_ptr.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/deconstruct_ptr.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/deconstruct_ptr.hpp	2009-01-31 20:12:03 EST (Sat, 31 Jan 2009)
@@ -1,3 +1,5 @@
+// DEPRECATED in favor of adl_postconstruct and adl_predestruct with
+// deconstruct<T>().
 // A factory function for creating a shared_ptr that enhances the plain
 // shared_ptr constructors by adding support for postconstructors
 // and predestructors through the boost::signals2::postconstructible and

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/postconstructible.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/postconstructible.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/postconstructible.hpp	2009-01-31 20:12:03 EST (Sat, 31 Jan 2009)
@@ -1,3 +1,4 @@
+// DEPRECATED in favor of adl_postconstruct with deconstruct<T>().
 // A simple framework for creating objects with postconstructors.
 // The objects must inherit from boost::signals2::postconstructible, and
 // have their lifetimes managed by
@@ -18,21 +19,34 @@
 {
   namespace signals2
   {
-    class postconstructible;
-    namespace detail
+    namespace postconstructible_adl_barrier
     {
-      void do_postconstruct(const boost::signals2::postconstructible *ptr);
+      class postconstructible;
     }
-
-    class postconstructible
+    namespace detail
+    {
+      void do_postconstruct(const boost::signals2::postconstructible_adl_barrier::postconstructible *ptr);
+    } // namespace detail
+    
+    namespace postconstructible_adl_barrier
     {
-    public:
-      friend void detail::do_postconstruct(const boost::signals2::postconstructible *ptr);
-    protected:
-      postconstructible() {}
-      virtual ~postconstructible() {}
-      virtual void postconstruct() = 0;
-    };
+      class postconstructible
+      {
+      public:
+        friend void detail::do_postconstruct(const postconstructible *ptr);
+        template<typename T>
+          friend void adl_postconstruct(const shared_ptr<T> &sp, postconstructible *p)
+        {
+          p->postconstruct();
+        }
+      protected:
+        postconstructible() {}
+        virtual ~postconstructible() {}
+        virtual void postconstruct() = 0;
+      };
+    } // namespace postconstructible_adl_barrier
+    using postconstructible_adl_barrier::postconstructible;
+    
   }
 }
 

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/predestructible.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/predestructible.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/predestructible.hpp	2009-01-31 20:12:03 EST (Sat, 31 Jan 2009)
@@ -1,3 +1,4 @@
+// DEPRECATED in favor of adl_predestruct with deconstruct<T>().
 // A simple framework for creating objects with predestructors.
 // The objects must inherit from boost::signals2::predestructible, and
 // have their lifetimes managed by
@@ -20,14 +21,25 @@
   {
     template<typename T> class predestructing_deleter;
 
-    class predestructible
+    namespace predestructible_adl_barrier
     {
-    protected:
-      predestructible() {}
-    public:
-      virtual ~predestructible() {}
-      virtual void predestruct() = 0;
-    };
+      class predestructible
+      {
+      protected:
+        predestructible() {}
+      public:
+        template<typename T>
+          friend void adl_postconstruct(const shared_ptr<T> &, ...)
+        {};
+        friend void adl_predestruct(predestructible *p)
+        {
+          p->predestruct();
+        }
+        virtual ~predestructible() {}
+        virtual void predestruct() = 0;
+      };
+    } // namespace predestructible_adl_barrier
+    using predestructible_adl_barrier::predestructible;
   }
 }
 

Modified: sandbox/thread_safe_signals/trunk/libs/signals2/test/deconstruct_test.cpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/libs/signals2/test/deconstruct_test.cpp	(original)
+++ sandbox/thread_safe_signals/trunk/libs/signals2/test/deconstruct_test.cpp	2009-01-31 20:12:03 EST (Sat, 31 Jan 2009)
@@ -53,6 +53,7 @@
   {
     BOOST_CHECK(_postconstructed);
   }
+  int value;
 protected:
   virtual void postconstruct()
   {
@@ -61,10 +62,58 @@
   bool _postconstructed;
 private:
   friend class boost::signals2::deconstruct_access;
-  by_deconstruct_only(int): _postconstructed(false)
+  by_deconstruct_only(int value_in):
+    value(value_in), _postconstructed(false)
   {}
 };
 
+namespace mytest
+{
+  class A
+  {
+  public:
+    template<typename T> friend
+      void adl_postconstruct(const boost::shared_ptr<T> &sp, A *p)
+    {
+      if(p)
+      {
+        p->_postconstructed = true;
+      }
+    }
+    template<typename T> friend
+      void adl_postconstruct(const boost::shared_ptr<T> &sp, A *p, int val)
+    {
+      if(p)
+      {
+        p->value = val;
+        p->_postconstructed = true;
+      }
+    }
+    friend void adl_predestruct(A *p)
+    {
+      if(p)
+      {
+        p->_predestructed = true;
+      }
+    }
+    ~A()
+    {
+      BOOST_CHECK(_postconstructed);
+      BOOST_CHECK(_predestructed);
+    }
+    int value;
+  private:
+    friend class boost::signals2::deconstruct_access;
+    A(int value_in):
+      value(value_in),
+      _postconstructed(false),
+      _predestructed(false)
+    {}
+    bool _postconstructed;
+    bool _predestructed;
+  };
+}
+
 void deconstruct_ptr_test()
 {
   {
@@ -91,6 +140,19 @@
   }
   {
     boost::shared_ptr<by_deconstruct_only> a = boost::signals2::deconstruct<by_deconstruct_only>(1);
+    BOOST_CHECK(a->value == 1);
+  }
+  {
+    boost::shared_ptr<mytest::A> a = boost::signals2::deconstruct<mytest::A>(1);
+    BOOST_CHECK(a->value == 1);
+  }
+  {// deconstruct const type
+    boost::shared_ptr<const mytest::A> a = boost::signals2::deconstruct<const mytest::A>(3);
+    BOOST_CHECK(a->value == 3);
+  }
+  {// passing arguments to postconstructor
+    boost::shared_ptr<mytest::A> a = boost::signals2::deconstruct<mytest::A>(1).postconstruct(2);
+    BOOST_CHECK(a->value == 2);
   }
 }