fix: disable move in generated adaptor and proxy classes (#435)

Moving adaptor or proxy instances changes their `this` pointer. But `this` is captured by value in closures used by those instances, and this remains unchanged on move, leading to accessing an invalid instance when a lambda expression executes. Supporting move semantics would require unsubscribing/unregistering vtable, handlers, etc. and re-subscribing and re-registering all that, which is too complicated and may have side effects. Hence it has been decided that these classes are not moveable. One may use an indirection with e.g. `std::unique_ptr` to get move semantics.

tests/stresstests/celsius-thermometer-adaptor.h

@@ -22,27 +22,27 @@ public:
 
 protected:
     thermometer_adaptor(sdbus::IObject& object)
-        : object_(&object)
+        : m_object(object)
     {
     }
 
     thermometer_adaptor(const thermometer_adaptor&) = delete;
     thermometer_adaptor& operator=(const thermometer_adaptor&) = delete;
-    thermometer_adaptor(thermometer_adaptor&&) = default;
-    thermometer_adaptor& operator=(thermometer_adaptor&&) = default;
+    thermometer_adaptor(thermometer_adaptor&&) = delete;
+    thermometer_adaptor& operator=(thermometer_adaptor&&) = delete;
 
     ~thermometer_adaptor() = default;
 
     void registerAdaptor()
     {
-        object_->addVTable(sdbus::registerMethod("getCurrentTemperature").withOutputParamNames("result").implementedAs([this](){ return this->getCurrentTemperature(); })).forInterface(INTERFACE_NAME);
+        m_object.addVTable(sdbus::registerMethod("getCurrentTemperature").withOutputParamNames("result").implementedAs([this](){ return this->getCurrentTemperature(); })).forInterface(INTERFACE_NAME);
     }
 
 private:
     virtual uint32_t getCurrentTemperature() = 0;
 
 private:
-    sdbus::IObject* object_;
+    sdbus::IObject& m_object;
 };
 
 }}}} // namespaces

tests/stresstests/celsius-thermometer-proxy.h

@@ -22,14 +22,14 @@ public:
 
 protected:
     thermometer_proxy(sdbus::IProxy& proxy)
-        : proxy_(&proxy)
+        : m_proxy(proxy)
     {
     }
 
     thermometer_proxy(const thermometer_proxy&) = delete;
     thermometer_proxy& operator=(const thermometer_proxy&) = delete;
-    thermometer_proxy(thermometer_proxy&&) = default;
-    thermometer_proxy& operator=(thermometer_proxy&&) = default;
+    thermometer_proxy(thermometer_proxy&&) = delete;
+    thermometer_proxy& operator=(thermometer_proxy&&) = delete;
 
     ~thermometer_proxy() = default;
 
@@ -41,12 +41,12 @@ public:
     uint32_t getCurrentTemperature()
     {
         uint32_t result;
-        proxy_->callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        m_proxy.callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
 private:
-    sdbus::IProxy* proxy_;
+    sdbus::IProxy& m_proxy;
 };
 
 }}}} // namespaces

tests/stresstests/concatenator-adaptor.h

@@ -21,20 +21,20 @@ public:
 
 protected:
     concatenator_adaptor(sdbus::IObject& object)
-        : object_(&object)
+        : m_object(object)
     {
     }
 
     concatenator_adaptor(const concatenator_adaptor&) = delete;
     concatenator_adaptor& operator=(const concatenator_adaptor&) = delete;
-    concatenator_adaptor(concatenator_adaptor&&) = default;
-    concatenator_adaptor& operator=(concatenator_adaptor&&) = default;
+    concatenator_adaptor(concatenator_adaptor&&) = delete;
+    concatenator_adaptor& operator=(concatenator_adaptor&&) = delete;
 
     ~concatenator_adaptor() = default;
 
     void registerAdaptor()
     {
-        object_->addVTable( sdbus::registerMethod("concatenate").withInputParamNames("params").withOutputParamNames("result").implementedAs([this](sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params){ this->concatenate(std::move(result), std::move(params)); })
+        m_object.addVTable( sdbus::registerMethod("concatenate").withInputParamNames("params").withOutputParamNames("result").implementedAs([this](sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params){ this->concatenate(std::move(result), std::move(params)); })
                           , sdbus::registerSignal("concatenatedSignal").withParameters<std::string>("concatenatedString")
                           ).forInterface(INTERFACE_NAME);
     }
@@ -42,14 +42,14 @@ protected:
 public:
     void emitConcatenatedSignal(const std::string& concatenatedString)
     {
-        object_->emitSignal("concatenatedSignal").onInterface(INTERFACE_NAME).withArguments(concatenatedString);
+        m_object.emitSignal("concatenatedSignal").onInterface(INTERFACE_NAME).withArguments(concatenatedString);
     }
 
 private:
     virtual void concatenate(sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params) = 0;
 
 private:
-    sdbus::IObject* object_;
+    sdbus::IObject& m_object;
 };
 
 }}} // namespaces

tests/stresstests/concatenator-proxy.h

@@ -21,20 +21,20 @@ public:
 
 protected:
     concatenator_proxy(sdbus::IProxy& proxy)
-        : proxy_(&proxy)
+        : m_proxy(proxy)
     {
     }
 
     concatenator_proxy(const concatenator_proxy&) = delete;
     concatenator_proxy& operator=(const concatenator_proxy&) = delete;
-    concatenator_proxy(concatenator_proxy&&) = default;
-    concatenator_proxy& operator=(concatenator_proxy&&) = default;
+    concatenator_proxy(concatenator_proxy&&) = delete;
+    concatenator_proxy& operator=(concatenator_proxy&&) = delete;
 
     ~concatenator_proxy() = default;
 
     void registerProxy()
     {
-        proxy_->uponSignal("concatenatedSignal").onInterface(INTERFACE_NAME).call([this](const std::string& concatenatedString){ this->onConcatenatedSignal(concatenatedString); });
+        m_proxy.uponSignal("concatenatedSignal").onInterface(INTERFACE_NAME).call([this](const std::string& concatenatedString){ this->onConcatenatedSignal(concatenatedString); });
     }
 
     virtual void onConcatenatedSignal(const std::string& concatenatedString) = 0;
@@ -44,11 +44,11 @@ protected:
 public:
     sdbus::PendingAsyncCall concatenate(const std::map<std::string, sdbus::Variant>& params)
     {
-        return proxy_->callMethodAsync("concatenate").onInterface(INTERFACE_NAME).withArguments(params).uponReplyInvoke([this](std::optional<sdbus::Error> error, const std::string& result){ this->onConcatenateReply(result, std::move(error)); });
+        return m_proxy.callMethodAsync("concatenate").onInterface(INTERFACE_NAME).withArguments(params).uponReplyInvoke([this](std::optional<sdbus::Error> error, const std::string& result){ this->onConcatenateReply(result, std::move(error)); });
     }
 
 private:
-    sdbus::IProxy* proxy_;
+    sdbus::IProxy& m_proxy;
 };
 
 }}} // namespaces

tests/stresstests/fahrenheit-thermometer-adaptor.h

@@ -22,27 +22,27 @@ public:
 
 protected:
     thermometer_adaptor(sdbus::IObject& object)
-        : object_(&object)
+        : m_object(object)
     {
     }
 
     thermometer_adaptor(const thermometer_adaptor&) = delete;
     thermometer_adaptor& operator=(const thermometer_adaptor&) = delete;
-    thermometer_adaptor(thermometer_adaptor&&) = default;
-    thermometer_adaptor& operator=(thermometer_adaptor&&) = default;
+    thermometer_adaptor(thermometer_adaptor&&) = delete;
+    thermometer_adaptor& operator=(thermometer_adaptor&&) = delete;
 
     ~thermometer_adaptor() = default;
 
     void registerAdaptor()
     {
-        object_->addVTable(sdbus::registerMethod("getCurrentTemperature").withOutputParamNames("result").implementedAs([this](){ return this->getCurrentTemperature(); })).forInterface(INTERFACE_NAME);
+        m_object.addVTable(sdbus::registerMethod("getCurrentTemperature").withOutputParamNames("result").implementedAs([this](){ return this->getCurrentTemperature(); })).forInterface(INTERFACE_NAME);
     }
 
 private:
     virtual uint32_t getCurrentTemperature() = 0;
 
 private:
-    sdbus::IObject* object_;
+    sdbus::IObject& m_object;
 };
 
 }}}} // namespaces
@@ -60,20 +60,20 @@ public:
 
 protected:
     factory_adaptor(sdbus::IObject& object)
-        : object_(&object)
+        : m_object(object)
     {
     }
 
     factory_adaptor(const factory_adaptor&) = delete;
     factory_adaptor& operator=(const factory_adaptor&) = delete;
-    factory_adaptor(factory_adaptor&&) = default;
-    factory_adaptor& operator=(factory_adaptor&&) = default;
+    factory_adaptor(factory_adaptor&&) = delete;
+    factory_adaptor& operator=(factory_adaptor&&) = delete;
 
     ~factory_adaptor() = default;
 
     void registerAdaptor()
     {
-        object_->addVTable( sdbus::registerMethod("createDelegateObject").withOutputParamNames("delegate").implementedAs([this](sdbus::Result<sdbus::ObjectPath>&& result){ this->createDelegateObject(std::move(result)); })
+        m_object.addVTable( sdbus::registerMethod("createDelegateObject").withOutputParamNames("delegate").implementedAs([this](sdbus::Result<sdbus::ObjectPath>&& result){ this->createDelegateObject(std::move(result)); })
                           , sdbus::registerMethod("destroyDelegateObject").withInputParamNames("delegate").implementedAs([this](sdbus::Result<>&& result, sdbus::ObjectPath delegate){ this->destroyDelegateObject(std::move(result), std::move(delegate)); }).withNoReply()
                           ).forInterface(INTERFACE_NAME);
     }
@@ -83,7 +83,7 @@ private:
     virtual void destroyDelegateObject(sdbus::Result<>&& result, sdbus::ObjectPath delegate) = 0;
 
 private:
-    sdbus::IObject* object_;
+    sdbus::IObject& m_object;
 };
 
 }}}}} // namespaces

tests/stresstests/fahrenheit-thermometer-proxy.h

@@ -22,14 +22,14 @@ public:
 
 protected:
     thermometer_proxy(sdbus::IProxy& proxy)
-        : proxy_(&proxy)
+        : m_proxy(proxy)
     {
     }
 
     thermometer_proxy(const thermometer_proxy&) = delete;
     thermometer_proxy& operator=(const thermometer_proxy&) = delete;
-    thermometer_proxy(thermometer_proxy&&) = default;
-    thermometer_proxy& operator=(thermometer_proxy&&) = default;
+    thermometer_proxy(thermometer_proxy&&) = delete;
+    thermometer_proxy& operator=(thermometer_proxy&&) = delete;
 
     ~thermometer_proxy() = default;
 
@@ -41,12 +41,12 @@ public:
     uint32_t getCurrentTemperature()
     {
         uint32_t result;
-        proxy_->callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        m_proxy.callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
 private:
-    sdbus::IProxy* proxy_;
+    sdbus::IProxy& m_proxy;
 };
 
 }}}} // namespaces
@@ -64,14 +64,14 @@ public:
 
 protected:
     factory_proxy(sdbus::IProxy& proxy)
-        : proxy_(&proxy)
+        : m_proxy(proxy)
     {
     }
 
     factory_proxy(const factory_proxy&) = delete;
     factory_proxy& operator=(const factory_proxy&) = delete;
-    factory_proxy(factory_proxy&&) = default;
-    factory_proxy& operator=(factory_proxy&&) = default;
+    factory_proxy(factory_proxy&&) = delete;
+    factory_proxy& operator=(factory_proxy&&) = delete;
 
     ~factory_proxy() = default;
 
@@ -83,17 +83,17 @@ public:
     sdbus::ObjectPath createDelegateObject()
     {
         sdbus::ObjectPath result;
-        proxy_->callMethod("createDelegateObject").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        m_proxy.callMethod("createDelegateObject").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
     void destroyDelegateObject(const sdbus::ObjectPath& delegate)
     {
-        proxy_->callMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).withArguments(delegate).dontExpectReply();
+        m_proxy.callMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).withArguments(delegate).dontExpectReply();
     }
 
 private:
-    sdbus::IProxy* proxy_;
+    sdbus::IProxy& m_proxy;
 };
 
 }}}}} // namespaces