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

Subject: [Boost-commit] svn:boost r49003 - in sandbox/thread_safe_signals/trunk: boost/signals2 boost/signals2/detail libs/signals2/test
From: fmhess_at_[hidden]
Date: 2008-09-29 11:05:05

Author: fmhess
Date: 2008-09-29 11:05:04 EDT (Mon, 29 Sep 2008)
New Revision: 49003
URL: http://svn.boost.org/trac/boost/changeset/49003

Log:
Tweaked interface of connection_body_base a bit.  Added free swap functions
for connection classes.  Added scoped_connection::release.  Made
scoped_connection noncopyable.

Added:
   sandbox/thread_safe_signals/trunk/libs/signals2/test/connection_test.cpp   (contents, props changed)
Text files modified: 
   sandbox/thread_safe_signals/trunk/boost/signals2/connection.hpp                |    90 ++++++++++++++++++++++++++++------------
   sandbox/thread_safe_signals/trunk/boost/signals2/detail/signal_template.hpp    |     4                                         
   sandbox/thread_safe_signals/trunk/boost/signals2/detail/slot_call_iterator.hpp |     4                                         
   sandbox/thread_safe_signals/trunk/libs/signals2/test/regression_test.cpp       |     2                                         
   sandbox/thread_safe_signals/trunk/libs/signals2/test/signal_n_test.cpp         |     2                                         
   5 files changed, 69 insertions(+), 33 deletions(-)

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/connection.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/connection.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/connection.hpp	2008-09-29 11:05:04 EDT (Mon, 29 Sep 2008)
@@ -40,13 +40,27 @@
         {
         }
         virtual ~connection_body_base() {}
-        virtual void disconnect() = 0;
+        void disconnect()
+        {
+          unique_lock<connection_body_base> lock(*this);
+          nolock_disconnect();
+        }
         void nolock_disconnect()
         {
           _connected = false;
         }
         virtual bool connected() const = 0;
-        virtual shared_ptr<void> get_blocker() = 0;
+        shared_ptr<void> get_blocker()
+        {
+          unique_lock<connection_body_base> lock(*this);
+          shared_ptr<void> blocker = _weak_blocker.lock();
+          if(blocker == 0)
+          {
+            blocker.reset(this, &null_deleter);
+            _weak_blocker = blocker;
+          }
+          return blocker;
+        }
         bool blocked() const
         {
           return !_weak_blocker.expired();
@@ -56,6 +70,10 @@
           return nolock_nograb_connected() == false || blocked();
         }
         bool nolock_nograb_connected() const {return _connected;}
+        // expose part of Lockable concept of mutex
+        virtual void lock() = 0;
+        virtual void unlock() = 0;
+
       protected:
 
         mutable bool _connected;
@@ -72,28 +90,12 @@
         {
         }
         virtual ~connection_body() {}
-        virtual void disconnect()
-        {
-          unique_lock<mutex_type> lock(mutex);
-          nolock_disconnect();
-        }
         virtual bool connected() const
         {
-          unique_lock<mutex_type> lock(mutex);
+          unique_lock<mutex_type> lock(_mutex);
           nolock_grab_tracked_objects();
           return nolock_nograb_connected();
         }
-        virtual shared_ptr<void> get_blocker()
-        {
-          unique_lock<mutex_type> lock(mutex);
-          shared_ptr<void> blocker = _weak_blocker.lock();
-          if(blocker == 0)
-          {
-            blocker.reset(this, &null_deleter);
-            _weak_blocker = blocker;
-          }
-          return blocker;
-        }
         const GroupKey& group_key() const {return _group_key;}
         void set_group_key(const GroupKey &key) {_group_key = key;}
         bool nolock_slot_expired() const
@@ -119,9 +121,18 @@
           }
           return locked_objects;
         }
+        // expose Lockable concept of mutex
+        virtual void lock()
+        {
+          _mutex.lock();
+        }
+        virtual void unlock()
+        {
+          _mutex.unlock();
+        }
         SlotType slot;
-        mutable mutex_type mutex;
       private:
+        mutable mutex_type _mutex;
         GroupKey _group_key;
       };
     }
@@ -136,7 +147,7 @@
       connection() {}
       connection(const connection &other): _weak_connection_body(other._weak_connection_body)
       {}
-      connection(boost::weak_ptr<detail::connection_body_base> connectionBody):
+      connection(const boost::weak_ptr<detail::connection_body_base> &connectionBody):
         _weak_connection_body(connectionBody)
       {}
       ~connection() {}
@@ -175,32 +186,57 @@
         using std::swap;
         swap(_weak_connection_body, other._weak_connection_body);
       }
-    private:
+    protected:
 
       boost::weak_ptr<detail::connection_body_base> _weak_connection_body;
     };
+    void swap(connection &conn1, connection &conn2)
+    {
+      conn1.swap(conn2);
+    }
 
     class scoped_connection: public connection
     {
     public:
-      scoped_connection() {}
-      scoped_connection(const connection &other): connection(other)
+      scoped_connection(): _released(false) {}
+      scoped_connection(const connection &other):
+        connection(other), _released(false)
       {}
       ~scoped_connection()
       {
-        disconnect();
+        if(_released == false)
+          disconnect();
       }
-      const scoped_connection& operator=(const connection &rhs)
+      scoped_connection& operator=(const connection &rhs)
       {
-        disconnect();
+        if(_released == false)
+          disconnect();
+        _released = false;
         connection::operator=(rhs);
         return *this;
       }
+      connection release()
+      {
+        connection conn(_weak_connection_body);
+        _released = true;
+        return conn;
+      }
       void swap(scoped_connection &other)
       {
         connection::swap(other);
+        using std::swap;
+        swap(_released, other._released);
       }
+    private:
+      scoped_connection(const scoped_connection &other);
+      scoped_connection& operator=(const scoped_connection &rhs);
+
+      bool _released;
     };
+    void swap(scoped_connection &conn1, scoped_connection &conn2)
+    {
+      conn1.swap(conn2);
+    }
   }
 }
 

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/detail/signal_template.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/detail/signal_template.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/detail/signal_template.hpp	2008-09-29 11:05:04 EDT (Mon, 29 Sep 2008)
@@ -288,7 +288,7 @@
           {
             bool connected;
             {
-              unique_lock<Mutex> lock((*it)->mutex);
+              unique_lock<connection_body_base> lock(**it);
               if(grab_tracked)
                 (*it)->nolock_slot_expired();
               connected = (*it)->nolock_nograb_connected();
@@ -354,7 +354,7 @@
           for(it = local_state->connection_bodies.begin();
             it != local_state->connection_bodies.end(); ++it)
           {
-            unique_lock<Mutex> lock((*it)->mutex);
+            unique_lock<connection_body_base> lock(**it);
             if((*it)->slot.slot_function() == slot)
             {
               (*it)->nolock_disconnect();

Modified: sandbox/thread_safe_signals/trunk/boost/signals2/detail/slot_call_iterator.hpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/boost/signals2/detail/slot_call_iterator.hpp	(original)
+++ sandbox/thread_safe_signals/trunk/boost/signals2/detail/slot_call_iterator.hpp	2008-09-29 11:05:04 EDT (Mon, 29 Sep 2008)
@@ -86,7 +86,7 @@
         }
 
       private:
-        typedef unique_lock<typename ConnectionBody::mutex_type> lock_type;
+        typedef unique_lock<connection_body_base> lock_type;
 
         void lock_next_callable() const
         {
@@ -96,7 +96,7 @@
           }
           for(;iter != end; ++iter)
           {
-            lock_type lock((*iter)->mutex);
+            lock_type lock(**iter);
             tracked_ptrs = (*iter)->nolock_grab_tracked_objects();
             if((*iter)->nolock_nograb_blocked() == false)
             {

Added: sandbox/thread_safe_signals/trunk/libs/signals2/test/connection_test.cpp
==============================================================================
--- (empty file)
+++ sandbox/thread_safe_signals/trunk/libs/signals2/test/connection_test.cpp	2008-09-29 11:05:04 EDT (Mon, 29 Sep 2008)
@@ -0,0 +1,88 @@
+// Signals2 library
+// tests for connection class
+
+// Copyright Frank Mori Hess 2008
+// Use, modification and
+// distribution is subject to 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)
+
+// For more information, see http://www.boost.org
+
+#include <boost/test/minimal.hpp>
+#include <boost/signals2.hpp>
+
+namespace bs2 = boost::signals2;
+
+typedef bs2::signal<void ()> sig_type;
+
+void myslot()
+{}
+
+void swap_test()
+{
+  sig_type sig;
+
+  {
+    bs2::connection conn1 = sig.connect(&myslot);
+    BOOST_CHECK(conn1.connected());
+    bs2::connection conn2;
+    BOOST_CHECK(conn2.connected() == false);
+
+    conn1.swap(conn2);
+    BOOST_CHECK(conn2.connected());
+    BOOST_CHECK(conn1.connected() == false);
+
+    swap(conn1, conn2);
+    BOOST_CHECK(conn1.connected());
+    BOOST_CHECK(conn2.connected() == false);
+  }
+
+  {
+    bs2::scoped_connection conn1 = sig.connect(&myslot);
+    BOOST_CHECK(conn1.connected());
+    bs2::scoped_connection conn2;
+    BOOST_CHECK(conn2.connected() == false);
+
+    conn1.swap(conn2);
+    BOOST_CHECK(conn2.connected());
+    BOOST_CHECK(conn1.connected() == false);
+
+    swap(conn1, conn2);
+    BOOST_CHECK(conn1.connected());
+    BOOST_CHECK(conn2.connected() == false);
+  }
+}
+
+void release_test()
+{
+  sig_type sig;
+  bs2::connection conn;
+  {
+    bs2::scoped_connection scoped(sig.connect(&myslot));
+    BOOST_CHECK(scoped.connected());
+    conn = scoped.release();
+  }
+  BOOST_CHECK(conn.connected());
+
+  bs2::connection conn2;
+  {
+    bs2::scoped_connection scoped(conn);
+    BOOST_CHECK(scoped.connected());
+    conn = scoped.release();
+    conn.disconnect();
+    BOOST_CHECK(scoped.connected() == false);
+
+    // earlier release shouldn't affect new connection
+    bs2::connection conn2 = sig.connect(&myslot);
+    scoped = conn2;
+  }
+  BOOST_CHECK(conn2.connected() == false);
+}
+
+int test_main(int, char*[])
+{
+  release_test();
+  swap_test();
+  return 0;
+}

Modified: sandbox/thread_safe_signals/trunk/libs/signals2/test/regression_test.cpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/libs/signals2/test/regression_test.cpp	(original)
+++ sandbox/thread_safe_signals/trunk/libs/signals2/test/regression_test.cpp	2008-09-29 11:05:04 EDT (Mon, 29 Sep 2008)
@@ -67,7 +67,7 @@
   typedef boost::signals2::signal0<void, slot_counter> signal_type;
   signal_type sig;
   {
-    boost::signals2::scoped_connection conn = sig.connect(&my_slot);
+    boost::signals2::scoped_connection conn(sig.connect(&my_slot));
     BOOST_CHECK(sig() == 1);
     conn = sig.connect(&my_slot);
     BOOST_CHECK(sig() == 1);

Modified: sandbox/thread_safe_signals/trunk/libs/signals2/test/signal_n_test.cpp
==============================================================================
--- sandbox/thread_safe_signals/trunk/libs/signals2/test/signal_n_test.cpp	(original)
+++ sandbox/thread_safe_signals/trunk/libs/signals2/test/signal_n_test.cpp	2008-09-29 11:05:04 EDT (Mon, 29 Sep 2008)
@@ -179,7 +179,7 @@
   boost::signals2::signal0<void> s;
 
   {
-    boost::signals2::scoped_connection c = s.connect(boost::ref(ec));
+    boost::signals2::scoped_connection c(s.connect(boost::ref(ec)));
     BOOST_CHECK(ec.count == 0);
     s();
     BOOST_CHECK(ec.count == 1);