Merge lp:~thomas-voss/properties-cpp/make-scoped-connection-movable into lp:properties-cpp

[Thomas Voß]

Refactor to rely on default move-operator for core::Connection.
Enable property chaining.
Make sure that an abandoned connection safely accesses its private member.
Make ScopedConnection a movable type.

Refactor to rely on default move-operator for core::Connection.
Enable property chaining.
Make sure that an abandoned connection safely accesses its private member.
Make ScopedConnection a movable type.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:13
http://jenkins.qa.ubuntu.com/job/properties-cpp-ci/4/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/properties-cpp-trusty-amd64-ci/4
    SUCCESS: http://jenkins.qa.ubuntu.com/job/properties-cpp-trusty-armhf-ci/4
        deb: http://jenkins.qa.ubuntu.com/job/properties-cpp-trusty-armhf-ci/4/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/properties-cpp-trusty-i386-ci/4

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/properties-cpp-ci/4/rebuild

review: Approve (continuous-integration)

=== modified file 'include/core/connection.h'
--- include/core/connection.h	2013-11-28 07:35:14 +0000
+++ include/core/connection.h	2014-01-13 16:44:20 +0000
@@ -24,6 +24,7 @@
 
 namespace core
 {
+class ScopedConnection;
 /**
  * @brief The Connection class models a signal-slot connection.
  */
@@ -38,6 +39,9 @@
      */
     inline bool is_connected() const
     {
+        if (!d)
+            return false;
+
         return (d->disconnector ? true : false);
     }
 
@@ -46,7 +50,8 @@
      */
     inline void disconnect()
     {
-        d->disconnect();
+        if (d)
+            d->disconnect();
     }
 
     /**
@@ -55,11 +60,13 @@
      */
     inline void dispatch_via(const Dispatcher& dispatcher)
     {
-        if (d->dispatcher_installer)
+        if (d && d->dispatcher_installer)
             d->dispatcher_installer(dispatcher);
     }
 
 private:
+    friend class ScopedConnection;
+
     typedef std::function<void()> Disconnector;
     typedef std::function<void(const Dispatcher&)> DispatcherInstaller;
 
@@ -71,9 +78,15 @@
     {
     }
 
+    inline bool operator<(const Connection& rhs) const
+    {
+        return d < rhs.d;
+    }
+
     inline void reset()
     {
-        d->reset();
+        if (d)
+            d->reset();
     }
 
     struct Private
@@ -136,6 +149,10 @@
     {
     }
 
+    inline ScopedConnection(ScopedConnection&& rhs) : connection(std::move(rhs.connection))
+    {
+    }
+
     ScopedConnection(const ScopedConnection&) = delete;
 
     /**
@@ -151,9 +168,20 @@
         }
     }
 
+    inline ScopedConnection& operator=(ScopedConnection&& rhs)
+    {
+        connection = std::move(rhs.connection);
+        return *this;
+    }
+
     ScopedConnection& operator=(const ScopedConnection&) = delete;
     bool operator==(const ScopedConnection&) = delete;
 
+    inline bool operator<(const ScopedConnection& rhs) const
+    {
+        return connection < rhs.connection;
+    }
+
 private:
     Connection connection;
 };
 
=== modified file 'include/core/property.h'
--- include/core/property.h	2013-11-28 07:35:14 +0000
+++ include/core/property.h	2014-01-13 16:44:20 +0000
@@ -20,12 +20,17 @@
 
 #include <core/signal.h>
 
-#include <iostream>
+#include <set>
 
 namespace core
 {
 /**
  * @brief A very simple, templated class that allows for uniform declaration of get-able/set-able/observable members.
+ *
+ * A note on thread-safety: The property class itself does not give any thread-safety guarantees.
+ * That is, consumers must not assume that concurrent get() and set() operations are synchronized by
+ * this class.
+ *
  * @tparam The type of the value contained within the property.
  */
 template<typename T>
@@ -166,8 +171,19 @@
         return false;
     }
 
+    friend inline const Property<T>& operator|(const Property<T>& lhs, Property<T>& rhs)
+    {
+        rhs.connections.emplace(
+                    lhs.changed().connect(
+                        std::bind(
+                            &Property<T>::set,
+                            std::ref(rhs),
+                            std::placeholders::_1)));
+        return lhs;
+    }
+
   protected:
-    inline T& mutable_get() const
+    inline virtual T& mutable_get() const
     {
         return value;
     }
@@ -175,6 +191,7 @@
   private:
     mutable T value;
     Signal<T> signal_changed;
+    std::set<ScopedConnection> connections;
 };
 }
 
 
=== modified file 'tests/properties_test.cpp'
--- tests/properties_test.cpp	2013-11-28 07:35:14 +0000
+++ tests/properties_test.cpp	2014-01-13 16:44:20 +0000
@@ -166,3 +166,14 @@
 
     EXPECT_EQ(22, position);
 }
+
+TEST(Property, chaining_properties_works)
+{
+    core::Property<int> p1, p2;
+
+    p1 | p2;
+
+    p1.set(42);
+
+    EXPECT_EQ(42, p2.get());
+}