Bump revision up to 0.7.6

CMakeLists.txt

@@ -4,7 +4,7 @@
 
 cmake_minimum_required(VERSION 3.6)
 
-project(sdbus-c++ VERSION 0.7.4 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 0.7.6 LANGUAGES C CXX)
 
 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file
 
@@ -37,7 +37,6 @@ set(SDBUSCPP_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/${SDBUSCPP_INCLUDE_
 
 set(SDBUSCPP_CPP_SRCS
     ${SDBUSCPP_SOURCE_DIR}/Connection.cpp
-    ${SDBUSCPP_SOURCE_DIR}/ConvenienceApiClasses.cpp
     ${SDBUSCPP_SOURCE_DIR}/Error.cpp
     ${SDBUSCPP_SOURCE_DIR}/Message.cpp
     ${SDBUSCPP_SOURCE_DIR}/Object.cpp

ChangeLog

@@ -124,3 +124,10 @@ v0.7.4
 - Add support for custom timeout of D-Bus method calls
 - Add support for opening a connection to a remote system bus using ssh
 - Internal refactoring: Use tag dispatching to construct various types of Connection
+
+v0.7.5
+- [[Breaking ABI change]] No more hiding from C++17: Move API code containing C++17 uncaught_exceptions calls from within library to public API
+- Add a method to retrieve the unique name of a connection
+
+v0.7.6
+- Fixes of clang-8 errors and warnings

include/sdbus-c++/ConvenienceApiClasses.h

@@ -50,10 +50,9 @@ namespace sdbus {
     public:
         MethodRegistrator(IObject& object, const std::string& methodName);
         MethodRegistrator(MethodRegistrator&& other) = default;
-        MethodRegistrator& operator=(MethodRegistrator&& other) = default;
         ~MethodRegistrator() noexcept(false);
 
-        MethodRegistrator& onInterface(const std::string& interfaceName);
+        MethodRegistrator& onInterface(std::string interfaceName);
         template <typename _Function>
         std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
         template <typename _Function>
@@ -78,7 +77,6 @@ namespace sdbus {
     public:
         SignalRegistrator(IObject& object, const std::string& signalName);
         SignalRegistrator(SignalRegistrator&& other) = default;
-        SignalRegistrator& operator=(SignalRegistrator&& other) = default;
         ~SignalRegistrator() noexcept(false);
 
         SignalRegistrator& onInterface(std::string interfaceName);
@@ -99,10 +97,9 @@ namespace sdbus {
     public:
         PropertyRegistrator(IObject& object, const std::string& propertyName);
         PropertyRegistrator(PropertyRegistrator&& other) = default;
-        PropertyRegistrator& operator=(PropertyRegistrator&& other) = default;
         ~PropertyRegistrator() noexcept(false);
 
-        PropertyRegistrator& onInterface(const std::string& interfaceName);
+        PropertyRegistrator& onInterface(std::string interfaceName);
         template <typename _Function> PropertyRegistrator& withGetter(_Function&& callback);
         template <typename _Function> PropertyRegistrator& withSetter(_Function&& callback);
         PropertyRegistrator& markAsDeprecated();
@@ -125,7 +122,6 @@ namespace sdbus {
     public:
         InterfaceFlagsSetter(IObject& object, const std::string& interfaceName);
         InterfaceFlagsSetter(InterfaceFlagsSetter&& other) = default;
-        InterfaceFlagsSetter& operator=(InterfaceFlagsSetter&& other) = default;
         ~InterfaceFlagsSetter() noexcept(false);
 
         InterfaceFlagsSetter& markAsDeprecated();
@@ -145,7 +141,6 @@ namespace sdbus {
     public:
         SignalEmitter(IObject& object, const std::string& signalName);
         SignalEmitter(SignalEmitter&& other) = default;
-        SignalEmitter& operator=(SignalEmitter&& other) = default;
         ~SignalEmitter() noexcept(false);
         SignalEmitter& onInterface(const std::string& interfaceName);
         template <typename... _Args> void withArguments(_Args&&... args);
@@ -162,7 +157,6 @@ namespace sdbus {
     public:
         MethodInvoker(IProxy& proxy, const std::string& methodName);
         MethodInvoker(MethodInvoker&& other) = default;
-        MethodInvoker& operator=(MethodInvoker&& other) = default;
         ~MethodInvoker() noexcept(false);
 
         MethodInvoker& onInterface(const std::string& interfaceName);
@@ -205,12 +199,12 @@ namespace sdbus {
     {
     public:
         SignalSubscriber(IProxy& proxy, const std::string& signalName);
-        SignalSubscriber& onInterface(const std::string& interfaceName);
+        SignalSubscriber& onInterface(std::string interfaceName);
         template <typename _Function> void call(_Function&& callback);
 
     private:
         IProxy& proxy_;
-        std::string signalName_;
+        const std::string& signalName_;
         std::string interfaceName_;
     };
 
@@ -222,14 +216,14 @@ namespace sdbus {
 
     private:
         IProxy& proxy_;
-        std::string propertyName_;
+        const std::string& propertyName_;
     };
 
     class PropertySetter
     {
     public:
         PropertySetter(IProxy& proxy, const std::string& propertyName);
-        PropertySetter& onInterface(const std::string& interfaceName);
+        PropertySetter& onInterface(std::string interfaceName);
         template <typename _Value> void toValue(const _Value& value);
         void toValue(const sdbus::Variant& value);
 

include/sdbus-c++/ConvenienceApiClasses.inl

@@ -36,7 +36,8 @@
 #include <sdbus-c++/Error.h>
 #include <string>
 #include <tuple>
-/*#include <exception>*/
+#include <exception>
+#include <cassert>
 
 namespace sdbus {
 
@@ -44,12 +45,10 @@ namespace sdbus {
     /*** MethodRegistrator ***/
     /*** ----------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
     inline MethodRegistrator::MethodRegistrator(IObject& object, const std::string& methodName)
         : object_(object)
         , methodName_(methodName)
-        , exceptions_(std::uncaught_exceptions()) // Needs C++17
+        , exceptions_(std::uncaught_exceptions())
     {
     }
 
@@ -59,8 +58,8 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);
-        SDBUS_THROW_ERROR_IF(!methodCallback_, "Method handler not specified when registering a DBus method", EINVAL);
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
+        assert(methodCallback_); // implementedAs() must be placed/called prior to this function
 
         // registerMethod() can throw. But as the MethodRegistrator shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
@@ -73,11 +72,10 @@ namespace sdbus {
         // to the exception thrown from here if the caller is a destructor itself.
         object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(methodCallback_), flags_);
     }
-    */
 
-    inline MethodRegistrator& MethodRegistrator::onInterface(const std::string& interfaceName)
+    inline MethodRegistrator& MethodRegistrator::onInterface(std::string interfaceName)
     {
-        interfaceName_ = interfaceName;
+        interfaceName_ = std::move(interfaceName);
 
         return *this;
     }
@@ -157,11 +155,9 @@ namespace sdbus {
     /*** SignalRegistrator ***/
     /*** ----------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
-    inline SignalRegistrator::SignalRegistrator(IObject& object, std::string signalName)
+    inline SignalRegistrator::SignalRegistrator(IObject& object, const std::string& signalName)
         : object_(object)
-        , signalName_(std::move(signalName))
+        , signalName_(signalName)
         , exceptions_(std::uncaught_exceptions())
     {
     }
@@ -172,8 +168,7 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        if (interfaceName_.empty())
-            throw sdbus::Exception("DBus interface not specified when registering a DBus signal");
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
 
         // registerSignal() can throw. But as the SignalRegistrator shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
@@ -184,9 +179,8 @@ namespace sdbus {
         // Therefore, we can allow registerSignal() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerSignal(interfaceName_, signalName_, signalSignature_);
+        object_.registerSignal(interfaceName_, signalName_, signalSignature_, flags_);
     }
-    */
 
     inline SignalRegistrator& SignalRegistrator::onInterface(std::string interfaceName)
     {
@@ -214,11 +208,9 @@ namespace sdbus {
     /*** PropertyRegistrator ***/
     /*** ------------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
-    inline PropertyRegistrator::PropertyRegistrator(IObject& object, std::string propertyName)
+    inline PropertyRegistrator::PropertyRegistrator(IObject& object, const std::string& propertyName)
         : object_(object)
-        , propertyName_(std::move(propertyName))
+        , propertyName_(propertyName)
         , exceptions_(std::uncaught_exceptions())
     {
     }
@@ -229,7 +221,7 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus property", EINVAL);
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
 
         // registerProperty() can throw. But as the PropertyRegistrator shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
@@ -240,17 +232,17 @@ namespace sdbus {
         // Therefore, we can allow registerProperty() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerProperty( std::move(interfaceName_)
-                                , std::move(propertyName_)
-                                , std::move(propertySignature_)
+        object_.registerProperty( interfaceName_
+                                , propertyName_
+                                , propertySignature_
                                 , std::move(getter_)
-                                , std::move(setter_) );
+                                , std::move(setter_)
+                                , flags_ );
     }
-    */
 
-    inline PropertyRegistrator& PropertyRegistrator::onInterface(const std::string& interfaceName)
+    inline PropertyRegistrator& PropertyRegistrator::onInterface(std::string interfaceName)
     {
-        interfaceName_ = interfaceName;
+        interfaceName_ = std::move(interfaceName);
 
         return *this;
     }
@@ -323,8 +315,6 @@ namespace sdbus {
     /*** InterfaceFlagsSetter ***/
     /*** -------------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
     inline InterfaceFlagsSetter::InterfaceFlagsSetter(IObject& object, const std::string& interfaceName)
         : object_(object)
         , interfaceName_(interfaceName)
@@ -338,8 +328,6 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when setting its flags", EINVAL);
-
         // setInterfaceFlags() can throw. But as the InterfaceFlagsSetter shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
         // shall never happen. I.e. it should not happen that this destructor is directly called
@@ -349,10 +337,8 @@ namespace sdbus {
         // Therefore, we can allow setInterfaceFlags() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.setInterfaceFlags( std::move(interfaceName_)
-                                 , std::move(flags_) );
+        object_.setInterfaceFlags(interfaceName_, std::move(flags_));
     }
-    */
 
     inline InterfaceFlagsSetter& InterfaceFlagsSetter::markAsDeprecated()
     {
@@ -386,8 +372,6 @@ namespace sdbus {
     /*** SignalEmitter ***/
     /*** ------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
     inline SignalEmitter::SignalEmitter(IObject& object, const std::string& signalName)
         : object_(object)
         , signalName_(signalName)
@@ -401,9 +385,6 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        if (!signal_.isValid())
-            throw sdbus::Exception("DBus interface not specified when emitting a DBus signal");
-
         // emitSignal() can throw. But as the SignalEmitter shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
         // shall never happen. I.e. it should not happen that this destructor is directly called
@@ -415,7 +396,6 @@ namespace sdbus {
         // to the exception thrown from here if the caller is a destructor itself.
         object_.emitSignal(signal_);
     }
-    */
 
     inline SignalEmitter& SignalEmitter::onInterface(const std::string& interfaceName)
     {
@@ -427,7 +407,7 @@ namespace sdbus {
     template <typename... _Args>
     inline void SignalEmitter::withArguments(_Args&&... args)
     {
-        SDBUS_THROW_ERROR_IF(!signal_.isValid(), "DBus interface not specified when emitting a DBus signal", EINVAL);
+        assert(signal_.isValid()); // onInterface() must be placed/called prior to withArguments()
 
         detail::serialize_pack(signal_, std::forward<_Args>(args)...);
     }
@@ -436,9 +416,7 @@ namespace sdbus {
     /*** MethodInvoker ***/
     /*** ------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
-    inline MethodInvoker::MethodInvoker(IProxy& proxyObject, const std::string& methodName)
+    inline MethodInvoker::MethodInvoker(IProxy& proxy, const std::string& methodName)
         : proxy_(proxy)
         , methodName_(methodName)
         , exceptions_(std::uncaught_exceptions())
@@ -452,9 +430,6 @@ namespace sdbus {
         if (methodCalled_ || std::uncaught_exceptions() != exceptions_)
             return;
 
-        if (!method_.isValid())
-            throw sdbus::Exception("DBus interface not specified when calling a DBus method");
-
         // callMethod() can throw. But as the MethodInvoker shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
         // shall never happen. I.e. it should not happen that this destructor is directly called
@@ -464,9 +439,8 @@ namespace sdbus {
         // Therefore, we can allow callMethod() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        proxy_.callMethod(method_);
+        proxy_.callMethod(method_, timeout_);
     }
-    */
 
     inline MethodInvoker& MethodInvoker::onInterface(const std::string& interfaceName)
     {
@@ -492,7 +466,7 @@ namespace sdbus {
     template <typename... _Args>
     inline MethodInvoker& MethodInvoker::withArguments(_Args&&... args)
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
         detail::serialize_pack(method_, std::forward<_Args>(args)...);
 
@@ -502,7 +476,7 @@ namespace sdbus {
     template <typename... _Args>
     inline void MethodInvoker::storeResultsTo(_Args&... args)
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
         auto reply = proxy_.callMethod(method_, timeout_);
         methodCalled_ = true;
@@ -512,7 +486,7 @@ namespace sdbus {
 
     inline void MethodInvoker::dontExpectReply()
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
         method_.dontExpectReply();
     }
@@ -551,7 +525,7 @@ namespace sdbus {
     template <typename... _Args>
     inline AsyncMethodInvoker& AsyncMethodInvoker::withArguments(_Args&&... args)
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
         detail::serialize_pack(method_, std::forward<_Args>(args)...);
 
@@ -561,7 +535,7 @@ namespace sdbus {
     template <typename _Function>
     void AsyncMethodInvoker::uponReplyInvoke(_Function&& callback)
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
         auto asyncReplyHandler = [callback = std::forward<_Function>(callback)](MethodReply& reply, const Error* error)
         {
@@ -590,9 +564,9 @@ namespace sdbus {
     {
     }
 
-    inline SignalSubscriber& SignalSubscriber::onInterface(const std::string& interfaceName)
+    inline SignalSubscriber& SignalSubscriber::onInterface(std::string interfaceName)
     {
-        interfaceName_ = interfaceName;
+        interfaceName_ = std::move(interfaceName);
 
         return *this;
     }
@@ -600,7 +574,7 @@ namespace sdbus {
     template <typename _Function>
     inline void SignalSubscriber::call(_Function&& callback)
     {
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when subscribing to a signal", EINVAL);
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
 
         proxy_.registerSignalHandler( interfaceName_
                                     , signalName_
@@ -649,9 +623,9 @@ namespace sdbus {
     {
     }
 
-    inline PropertySetter& PropertySetter::onInterface(const std::string& interfaceName)
+    inline PropertySetter& PropertySetter::onInterface(std::string interfaceName)
     {
-        interfaceName_ = interfaceName;
+        interfaceName_ = std::move(interfaceName);
 
         return *this;
     }
@@ -664,7 +638,7 @@ namespace sdbus {
 
     inline void PropertySetter::toValue(const sdbus::Variant& value)
     {
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when setting a property", EINVAL);
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
 
         proxy_
             .callMethod("Set")

include/sdbus-c++/Error.h

@@ -27,7 +27,9 @@
 #ifndef SDBUS_CXX_ERROR_H_
 #define SDBUS_CXX_ERROR_H_
 
+#include <errno.h>
 #include <stdexcept>
+#include <string>
 
 namespace sdbus {
 

include/sdbus-c++/IConnection.h

@@ -74,6 +74,13 @@ namespace sdbus {
          */
         virtual void releaseName(const std::string& name) = 0;
 
+        /*!
+         * @brief Retrieve the unique name of a connection. E.g. ":1.xx"
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual std::string getUniqueName() const = 0;
+
         /*!
          * @brief Enters the D-Bus processing loop
          *
@@ -130,7 +137,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual PollData getProcessLoopPollData() = 0;
+        virtual PollData getProcessLoopPollData() const = 0;
 
         /*!
          * @brief Process a pending request

src/Connection.cpp

@@ -76,6 +76,14 @@ void Connection::releaseName(const std::string& name)
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to release bus name", -r);
 }
 
+std::string Connection::getUniqueName() const
+{
+    const char* unique = nullptr;
+    auto r = iface_->sd_bus_get_unique_name(bus_.get(), &unique);
+    SDBUS_THROW_ERROR_IF(r < 0 || unique == nullptr, "Failed to get unique bus name", -r);
+    return unique;
+}
+
 void Connection::enterProcessingLoop()
 {
     while (true)
@@ -102,7 +110,7 @@ void Connection::leaveProcessingLoop()
     joinWithProcessingLoop();
 }
 
-sdbus::IConnection::PollData Connection::getProcessLoopPollData()
+sdbus::IConnection::PollData Connection::getProcessLoopPollData() const
 {
     ISdBus::PollData pollData;
     auto r = iface_->sd_bus_get_poll_data(bus_.get(), &pollData);

src/Connection.h

@@ -57,10 +57,11 @@ namespace sdbus { namespace internal {
 
         void requestName(const std::string& name) override;
         void releaseName(const std::string& name) override;
+        std::string getUniqueName() const override;
         void enterProcessingLoop() override;
         void enterProcessingLoopAsync() override;
         void leaveProcessingLoop() override;
-        sdbus::IConnection::PollData getProcessLoopPollData() override;
+        sdbus::IConnection::PollData getProcessLoopPollData() const override;
         bool processPendingRequest() override;
 
         void addObjectManager(const std::string& objectPath) override;

src/ConvenienceApiClasses.cpp

@@ -1,209 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file ConvenienceApiClasses.cpp
- *
- * Created on: Jan 19, 2017
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "sdbus-c++/ConvenienceApiClasses.h"
-#include "sdbus-c++/IObject.h"
-#include "sdbus-c++/IProxy.h"
-#include <string>
-#include <exception>
-
-namespace sdbus {
-
-MethodRegistrator::MethodRegistrator(IObject& object, const std::string& methodName)
-    : object_(object)
-    , methodName_(methodName)
-    , exceptions_(std::uncaught_exceptions()) // Needs C++17
-{
-}
-
-MethodRegistrator::~MethodRegistrator() noexcept(false) // since C++11, destructors must
-{                                                       // explicitly be allowed to throw
-    // Don't register the method if MethodRegistrator threw an exception in one of its methods
-    if (std::uncaught_exceptions() != exceptions_)
-        return;
-
-    SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);
-    SDBUS_THROW_ERROR_IF(!methodCallback_, "Method handler not specified when registering a DBus method", EINVAL);
-
-    // registerMethod() can throw. But as the MethodRegistrator shall always be used as an unnamed,
-    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
-    // shall never happen. I.e. it should not happen that this destructor is directly called
-    // in the stack-unwinding process of another flying exception (which would lead to immediate
-    // termination). It can be called indirectly in the destructor of another object, but that's
-    // fine and safe provided that the caller catches exceptions thrown from here.
-    // Therefore, we can allow registerMethod() to throw even if we are in the destructor.
-    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
-    // to the exception thrown from here if the caller is a destructor itself.
-    object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(methodCallback_), flags_);
-}
-
-SignalRegistrator::SignalRegistrator(IObject& object, const std::string& signalName)
-    : object_(object)
-    , signalName_(signalName)
-    , exceptions_(std::uncaught_exceptions()) // Needs C++17
-{
-}
-
-SignalRegistrator::~SignalRegistrator() noexcept(false) // since C++11, destructors must
-{                                                       // explicitly be allowed to throw
-    // Don't register the signal if SignalRegistrator threw an exception in one of its methods
-    if (std::uncaught_exceptions() != exceptions_)
-        return;
-
-    SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus signal", EINVAL);
-
-    // registerSignal() can throw. But as the SignalRegistrator shall always be used as an unnamed,
-    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
-    // shall never happen. I.e. it should not happen that this destructor is directly called
-    // in the stack-unwinding process of another flying exception (which would lead to immediate
-    // termination). It can be called indirectly in the destructor of another object, but that's
-    // fine and safe provided that the caller catches exceptions thrown from here.
-    // Therefore, we can allow registerSignal() to throw even if we are in the destructor.
-    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
-    // to the exception thrown from here if the caller is a destructor itself.
-    object_.registerSignal(interfaceName_, signalName_, signalSignature_, flags_);
-}
-
-
-PropertyRegistrator::PropertyRegistrator(IObject& object, const std::string& propertyName)
-    : object_(object)
-    , propertyName_(propertyName)
-    , exceptions_(std::uncaught_exceptions())
-{
-}
-
-PropertyRegistrator::~PropertyRegistrator() noexcept(false) // since C++11, destructors must
-{                                                           // explicitly be allowed to throw
-    // Don't register the property if PropertyRegistrator threw an exception in one of its methods
-    if (std::uncaught_exceptions() != exceptions_)
-        return;
-
-    SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus property", EINVAL);
-
-    // registerProperty() can throw. But as the PropertyRegistrator shall always be used as an unnamed,
-    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
-    // shall never happen. I.e. it should not happen that this destructor is directly called
-    // in the stack-unwinding process of another flying exception (which would lead to immediate
-    // termination). It can be called indirectly in the destructor of another object, but that's
-    // fine and safe provided that the caller catches exceptions thrown from here.
-    // Therefore, we can allow registerProperty() to throw even if we are in the destructor.
-    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
-    // to the exception thrown from here if the caller is a destructor itself.
-    object_.registerProperty( std::move(interfaceName_)
-                            , std::move(propertyName_)
-                            , std::move(propertySignature_)
-                            , std::move(getter_)
-                            , std::move(setter_)
-                            , flags_ );
-}
-
-
-InterfaceFlagsSetter::InterfaceFlagsSetter(IObject& object, const std::string& interfaceName)
-    : object_(object)
-    , interfaceName_(interfaceName)
-    , exceptions_(std::uncaught_exceptions())
-{
-}
-
-InterfaceFlagsSetter::~InterfaceFlagsSetter() noexcept(false) // since C++11, destructors must
-{                                                                    // explicitly be allowed to throw
-    // Don't set any flags if InterfaceFlagsSetter threw an exception in one of its methods
-    if (std::uncaught_exceptions() != exceptions_)
-        return;
-
-    SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when setting its flags", EINVAL);
-
-    // setInterfaceFlags() can throw. But as the InterfaceFlagsSetter shall always be used as an unnamed,
-    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
-    // shall never happen. I.e. it should not happen that this destructor is directly called
-    // in the stack-unwinding process of another flying exception (which would lead to immediate
-    // termination). It can be called indirectly in the destructor of another object, but that's
-    // fine and safe provided that the caller catches exceptions thrown from here.
-    // Therefore, we can allow setInterfaceFlags() to throw even if we are in the destructor.
-    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
-    // to the exception thrown from here if the caller is a destructor itself.
-    object_.setInterfaceFlags( std::move(interfaceName_)
-                             , std::move(flags_) );
-}
-
-
-SignalEmitter::SignalEmitter(IObject& object, const std::string& signalName)
-    : object_(object)
-    , signalName_(signalName)
-    , exceptions_(std::uncaught_exceptions()) // Needs C++17
-{
-}
-
-SignalEmitter::~SignalEmitter() noexcept(false) // since C++11, destructors must
-{                                               // explicitly be allowed to throw
-    // Don't emit the signal if SignalEmitter threw an exception in one of its methods
-    if (std::uncaught_exceptions() != exceptions_)
-        return;
-
-    SDBUS_THROW_ERROR_IF(!signal_.isValid(), "DBus interface not specified when emitting a DBus signal", EINVAL);
-
-    // emitSignal() can throw. But as the SignalEmitter shall always be used as an unnamed,
-    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
-    // shall never happen. I.e. it should not happen that this destructor is directly called
-    // in the stack-unwinding process of another flying exception (which would lead to immediate
-    // termination). It can be called indirectly in the destructor of another object, but that's
-    // fine and safe provided that the caller catches exceptions thrown from here.
-    // Therefore, we can allow emitSignal() to throw even if we are in the destructor.
-    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
-    // to the exception thrown from here if the caller is a destructor itself.
-    object_.emitSignal(signal_);
-}
-
-
-MethodInvoker::MethodInvoker(IProxy& proxy, const std::string& methodName)
-    : proxy_(proxy)
-    , methodName_(methodName)
-    , exceptions_(std::uncaught_exceptions()) // Needs C++17
-{
-}
-
-MethodInvoker::~MethodInvoker() noexcept(false) // since C++11, destructors must
-{                                               // explicitly be allowed to throw
-    // Don't call the method if it has been called already or if MethodInvoker
-    // threw an exception in one of its methods
-    if (methodCalled_ || std::uncaught_exceptions() != exceptions_)
-        return;
-
-    SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
-
-    // callMethod() can throw. But as the MethodInvoker shall always be used as an unnamed,
-    // temporary object, i.e. not as a stack-allocated object, the double-exception situation
-    // shall never happen. I.e. it should not happen that this destructor is directly called
-    // in the stack-unwinding process of another flying exception (which would lead to immediate
-    // termination). It can be called indirectly in the destructor of another object, but that's
-    // fine and safe provided that the caller catches exceptions thrown from here.
-    // Therefore, we can allow callMethod() to throw even if we are in the destructor.
-    // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
-    // to the exception thrown from here if the caller is a destructor itself.
-    proxy_.callMethod(method_, timeout_);
-}
-
-}

src/ISdBus.h

@@ -70,6 +70,7 @@ namespace sdbus { namespace internal {
         virtual int sd_bus_open_system_remote(sd_bus **ret, const char* host) = 0;
         virtual int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) = 0;
         virtual int sd_bus_release_name(sd_bus *bus, const char *name) = 0;
+        virtual int sd_bus_get_unique_name(sd_bus *bus, const char **name) = 0;
         virtual int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata) = 0;
         virtual int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path) = 0;
         virtual int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) = 0;

src/Object.cpp

@@ -134,6 +134,8 @@ sdbus::Signal Object::createSignal(const std::string& interfaceName, const std::
 
 void Object::emitSignal(const sdbus::Signal& message)
 {
+    SDBUS_THROW_ERROR_IF(!message.isValid(), "Invalid signal message provided", EINVAL);
+
     message.send();
 }
 

src/Proxy.cpp

@@ -71,11 +71,15 @@ AsyncMethodCall Proxy::createAsyncMethodCall(const std::string& interfaceName, c
 
 MethodReply Proxy::callMethod(const MethodCall& message, uint64_t timeout)
 {
+    SDBUS_THROW_ERROR_IF(!message.isValid(), "Invalid method call message provided", EINVAL);
+
     return message.send(timeout);
 }
 
 void Proxy::callMethod(const AsyncMethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout)
 {
+    SDBUS_THROW_ERROR_IF(!message.isValid(), "Invalid async method call message provided", EINVAL);
+
     auto callback = (void*)&Proxy::sdbus_async_reply_handler;
     auto callData = std::make_unique<AsyncCalls::CallData>(AsyncCalls::CallData{*this, std::move(asyncReplyCallback), {}});
 

src/SdBus.cpp

@@ -183,6 +183,12 @@ int SdBus::sd_bus_release_name(sd_bus *bus, const char *name)
     return ::sd_bus_release_name(bus, name);
 }
 
+int SdBus::sd_bus_get_unique_name(sd_bus *bus, const char **name)
+{
+    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    return ::sd_bus_get_unique_name(bus, name);
+}
+
 int SdBus::sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata)
 {
     std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);

src/SdBus.h

@@ -62,6 +62,7 @@ public:
     virtual int sd_bus_open_system_remote(sd_bus **ret, const char* hsot) override;
     virtual int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) override;
     virtual int sd_bus_release_name(sd_bus *bus, const char *name) override;
+    virtual int sd_bus_get_unique_name(sd_bus *bus, const char **name) override;
     virtual int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata) override;
     virtual int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path) override;
     virtual int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) override;

tests/unittests/Types_test.cpp

@@ -67,7 +67,7 @@ TEST(AVariant, CanBeConstructedFromASimpleValue)
 TEST(AVariant, CanBeConstructedFromAComplexValue)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello", ANY_DOUBLE), sdbus::make_struct("world", ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
 
     ASSERT_NO_THROW(sdbus::Variant(value));
 }
@@ -103,7 +103,7 @@ TEST(ASimpleVariant, ReturnsTheSimpleValueWhenAsked)
 TEST(AComplexVariant, ReturnsTheComplexValueWhenAsked)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello", ANY_DOUBLE), sdbus::make_struct("world", ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
 
     sdbus::Variant variant(value);
 
@@ -123,7 +123,7 @@ TEST(AVariant, HasConceptuallyNonmutableGetMethodWhichCanBeCalledXTimes)
 TEST(AVariant, ReturnsTrueWhenAskedIfItContainsTheTypeItReallyContains)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello", ANY_DOUBLE), sdbus::make_struct("world", ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
 
     sdbus::Variant variant(value);
 
@@ -172,7 +172,7 @@ TEST(AnEmptyVariant, ThrowsWhenBeingSerializedToAMessage)
 TEST(ANonEmptyVariant, SerializesToAndDeserializesFromAMessageSuccessfully)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello", ANY_DOUBLE), sdbus::make_struct("world", ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
     sdbus::Variant variant(value);
 
     auto msg = sdbus::createPlainMessage();
@@ -187,7 +187,7 @@ TEST(ANonEmptyVariant, SerializesToAndDeserializesFromAMessageSuccessfully)
 TEST(CopiesOfVariant, SerializeToAndDeserializeFromMessageSuccessfully)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello", ANY_DOUBLE), sdbus::make_struct("world", ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
     sdbus::Variant variant(value);
     auto variantCopy1{variant};
     auto variantCopy2 = variant;

tests/unittests/mocks/SdBusMock.h

@@ -61,6 +61,7 @@ public:
     MOCK_METHOD2(sd_bus_open_system_remote, int(sd_bus **ret, const char *host));
     MOCK_METHOD3(sd_bus_request_name, int(sd_bus *bus, const char *name, uint64_t flags));
     MOCK_METHOD2(sd_bus_release_name, int(sd_bus *bus, const char *name));
+    MOCK_METHOD2(sd_bus_get_unique_name, int(sd_bus *bus, const char **name));
     MOCK_METHOD6(sd_bus_add_object_vtable, int(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata));
     MOCK_METHOD3(sd_bus_add_object_manager, int(sd_bus *bus, sd_bus_slot **slot, const char *path));
     MOCK_METHOD5(sd_bus_add_match, int(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata));