Bump up revision to 0.4.3

Add separation layer from sd-bus to improve isolation in unit testing

.project

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<projectDescription>
-	<name>sdbus-cpp</name>
-	<comment></comment>
-	<projects>
-	</projects>
-	<buildSpec>
-		<buildCommand>
-			<name>org.eclipse.cdt.autotools.core.genmakebuilderV2</name>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
-			<triggers>clean,full,incremental,</triggers>
-			<arguments>
-			</arguments>
-		</buildCommand>
-		<buildCommand>
-			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
-			<triggers>full,incremental,</triggers>
-			<arguments>
-			</arguments>
-		</buildCommand>
-	</buildSpec>
-	<natures>
-		<nature>org.eclipse.cdt.core.cnature</nature>
-		<nature>org.eclipse.cdt.core.ccnature</nature>
-		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
-		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
-		<nature>org.yocto.sdk.ide.YoctoSDKNature</nature>
-		<nature>org.eclipse.cdt.autotools.core.autotoolsNatureV2</nature>
-		<nature>org.yocto.sdk.ide.YoctoSDKAutotoolsNature</nature>
-	</natures>
-</projectDescription>

CMakeLists.txt

@@ -4,7 +4,7 @@
 
 cmake_minimum_required(VERSION 3.8)
 
-project(sdbus-c++ VERSION 0.3.2 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 0.4.3 LANGUAGES C CXX)
 
 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file
 
@@ -32,7 +32,9 @@ set(SDBUSCPP_CPP_SRCS
     ${SDBUSCPP_SOURCE_DIR}/Object.cpp
     ${SDBUSCPP_SOURCE_DIR}/ObjectProxy.cpp
     ${SDBUSCPP_SOURCE_DIR}/Types.cpp
-    ${SDBUSCPP_SOURCE_DIR}/VTableUtils.c)
+    ${SDBUSCPP_SOURCE_DIR}/Flags.cpp
+    ${SDBUSCPP_SOURCE_DIR}/VTableUtils.c
+    ${SDBUSCPP_SOURCE_DIR}/SdBus.cpp)
 
 set(SDBUSCPP_HDR_SRCS
     ${SDBUSCPP_SOURCE_DIR}/Connection.h
@@ -41,7 +43,9 @@ set(SDBUSCPP_HDR_SRCS
     ${SDBUSCPP_SOURCE_DIR}/Object.h
     ${SDBUSCPP_SOURCE_DIR}/ObjectProxy.h
     ${SDBUSCPP_SOURCE_DIR}/ScopeGuard.h
-    ${SDBUSCPP_SOURCE_DIR}/VTableUtils.h)
+    ${SDBUSCPP_SOURCE_DIR}/VTableUtils.h
+    ${SDBUSCPP_SOURCE_DIR}/SdBus.h
+    ${SDBUSCPP_SOURCE_DIR}/ISdBus.h)
 
 set(SDBUSCPP_PUBLIC_HDRS
     ${SDBUSCPP_INCLUDE_DIR}/ConvenienceClasses.h
@@ -56,7 +60,8 @@ set(SDBUSCPP_PUBLIC_HDRS
     ${SDBUSCPP_INCLUDE_DIR}/MethodResult.h
     ${SDBUSCPP_INCLUDE_DIR}/sdbus-c++.h
     ${SDBUSCPP_INCLUDE_DIR}/Types.h
-    ${SDBUSCPP_INCLUDE_DIR}/TypeTraits.h)
+    ${SDBUSCPP_INCLUDE_DIR}/TypeTraits.h
+    ${SDBUSCPP_INCLUDE_DIR}/Flags.h)
 
 set(SDBUSCPP_SRCS ${SDBUSCPP_CPP_SRCS} ${SDBUSCPP_HDR_SRCS} ${SDBUSCPP_PUBLIC_HDRS})
 
@@ -65,7 +70,6 @@ set(SDBUSCPP_SRCS ${SDBUSCPP_CPP_SRCS} ${SDBUSCPP_HDR_SRCS} ${SDBUSCPP_PUBLIC_HD
 #-------------------------------
 
 set(CMAKE_CXX_STANDARD 17)
-add_compile_options(-W -Wextra -Wall -Werror -pedantic)
 include_directories("${CMAKE_SOURCE_DIR}/include")
 include_directories("${CMAKE_SOURCE_DIR}/src")
 
@@ -133,12 +137,15 @@ endif()
 # CMAKE CONFIG & PACKAGE CONFIG
 #----------------------------------
 
+include(CMakePackageConfigHelpers)
 set(SDBUSCPP_CONFIG_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++)
 
 configure_file(sdbus-c++-config.cmake.in sdbus-c++-config.cmake @ONLY)
 install(FILES ${CMAKE_BINARY_DIR}/sdbus-c++-config.cmake DESTINATION ${SDBUSCPP_CONFIG_INSTALL_DIR} COMPONENT dev)
 
-configure_file(sdbus-c++-config-version.cmake.in sdbus-c++-config-version.cmake @ONLY)
+write_basic_package_version_file(sdbus-c++-config-version.cmake
+        VERSION ${PROJECT_VERSION}
+        COMPATIBILITY AnyNewerVersion)
 install(FILES ${CMAKE_BINARY_DIR}/sdbus-c++-config-version.cmake DESTINATION ${SDBUSCPP_CONFIG_INSTALL_DIR} COMPONENT dev)
 
 configure_file(sdbus-c++.pc.in sdbus-c++.pc @ONLY)

ChangeLog

@@ -1,36 +1,53 @@
-v0.2.3
-- Initially published version
-
-v0.2.4
-- Fixed closing of file descriptor of event loop's semaphore on exec
-- Fixed interrupt handling when polling
-- Improved tutorial
-- Fixed issue with googlemock
-- Added object proxy factory overload that takes unique_ptr to a connection
-- Workaround: Clang compilation error when compiling sdbus::Struct (seems like an issue of Clang)
-
-v0.2.5
-- Real fix for issue with sdbus::Struct inherited constructors
-- Little code refactorings and improvements
-
-v0.2.6
-- Fixed memory leak in Message copy operations
-
-v0.3.0
-- Introduced support for asynchronous server-side methods
-- Refactored the concept of Message into distinctive concrete message types
-- As this release comes with breaking API changes:
-    * if you're using lower-level API, please rename 'Message' to whatever concrete message type (MethodCall, MethodReply, Signal) is needed there,
-    * if you're using higher-level API, please re-compile and re-link your application against sdbus-c++,
-    * if you're using generated stub headers, please re-compile and re-link your application against sdbus-c++.
-
-v0.3.1
-- Fixed hogging the CPU by server with async methods (issue #15)
-
-v0.3.2
-- Switched from autotools to CMake build system
-
-v0.3.3
-- Minor fixes in tutorial examples
-- Add comment on threading traits of Variant and its const methods
-- Fix broken invariant of const Variant::peekValueType() method
+v0.2.3
+- Initially published version
+
+v0.2.4
+- Fixed closing of file descriptor of event loop's semaphore on exec
+- Fixed interrupt handling when polling
+- Improved tutorial
+- Fixed issue with googlemock
+- Added object proxy factory overload that takes unique_ptr to a connection
+- Workaround: Clang compilation error when compiling sdbus::Struct (seems like an issue of Clang)
+
+v0.2.5
+- Real fix for issue with sdbus::Struct inherited constructors
+- Little code refactorings and improvements
+
+v0.2.6
+- Fixed memory leak in Message copy operations
+
+v0.3.0
+- Introduced support for asynchronous server-side methods
+- Refactored the concept of Message into distinctive concrete message types
+- As this release comes with breaking API changes:
+    * if you're using lower-level API, please rename 'Message' to whatever concrete message type (MethodCall, MethodReply, Signal) is needed there,
+    * if you're using higher-level API, please re-compile and re-link your application against sdbus-c++,
+    * if you're using generated stub headers, please re-compile and re-link your application against sdbus-c++.
+
+v0.3.1
+- Fixed hogging the CPU by server with async methods (issue #15)
+
+v0.3.2
+- Switched from autotools to CMake build system
+
+v0.3.3
+- Minor fixes in tutorial examples
+- Add comment on threading traits of Variant and its const methods
+- Fix broken invariant of const Variant::peekValueType() method
+
+v0.4.0
+- Introduce support and implementation of common D-Bus annotations
+- Remove hard-coded warning-related compiler options from the build system
+
+v0.4.1
+- Change constexpr member into a getter method to be compatible across odr-usage rules of various compiler versions
+
+v0.4.2
+- Improve documentation
+- Minor code improvements
+- Introduce sdbus-c++ performance tests with measurements
+
+v0.4.3
+- Add another abstraction layer for sd-bus to improve isolation for unit testing
+- Minor code improvements for consistency and clarity
+- Not-existing interface name and object path fixes in integration tests

README.md

@@ -38,6 +38,7 @@ References/documentation
 * [D-Bus Specification](https://dbus.freedesktop.org/doc/dbus-specification.html)
 * [sd-bus Overview](http://0pointer.net/blog/the-new-sd-bus-api-of-systemd.html)
 * [Tutorial: Using sdbus-c++](doc/using-sdbus-c++.md)
+* [Systemd and dbus configuration](doc/systemd-dbus-config.md)
 
 Contributing
 ------------

doc/systemd-dbus-config.md

@@ -0,0 +1,54 @@
+Systemd and dbus configuration
+=======================
+
+**Table of contents**
+
+1. [Introduction](#introduction)
+2. [Systemd configuration](#systemd-configuration)
+3. [Dbus configuration](#dbus-configuration)
+
+Introduction
+------------
+
+To run executable as a systemd service you may need some additional setup. For example, you may need explicitly allow 
+the usage of your service. Following chapters contain template configurations.
+
+
+Systemd configuration
+---------------------------------------
+
+Filename should use `.service` extension. It also must be placed in configuration directory (/etc/systemd/system in
+Ubuntu 18.04.1 LTS) 
+
+```
+[Unit]
+Description=nameOfService
+
+[Service]
+ExecStart=/path/to/executable
+
+[Install]
+WantedBy=multi-user.target
+```
+
+Dbus configuration
+------------------
+
+Typical default D-Bus configuration does not allow to register services except explicitly allowed. Filename should 
+contain name of your service, e.g `/etc/dbus-1/system.d/org.sdbuscpp.concatenator.conf`. So, here is template
+configuration to use dbus interface under root:
+
+```
+<!DOCTYPE busconfig PUBLIC
+ "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+  <policy user="root">
+    <allow own="org.sdbuscpp.concatenator"/>
+    <allow send_destination="org.sdbuscpp"/>
+    <allow send_interface="org.sdbuscpp.concatenator"/>
+  </policy>
+</busconfig>
+```
+
+If you need access from other user `root` should be substituted by desired username. For more refer to `man dbus-daemon`.

doc/using-sdbus-c++.md

@@ -29,21 +29,19 @@ method calls, signals and properties. There is room for additions and improvemen
 Integrating sdbus-c++ into your project
 ---------------------------------------
 
-The library build system is based on Autotools. The library supports `pkg-config`, so integrating it into your autotools project 
-is a two step process.
+The library build system is based on CMake. The library provides a config file, so integrating it into your CMake project is rather straight-forward:
 
-1. Add `PKG_CHECK_MODULES` macro into your `configure.ac`:
 ```bash
-PKG_CHECK_MODULES(SDBUSCPP, [sdbus-c++ >= 0.1],,
-    AC_MSG_ERROR([You need the sdbus-c++ library (version 0.1 or better)]
-    [http://www.kistler.com/])
-)
+find_package(sdbus-c++ REQUIRED)
 ```
 
-2. Update `*_CFLAGS` and `*_LDFLAGS` in Makefiles of modules that use *sdbus-c++*, for example like this:
+The library also supports `pkg-config`, so it easily be integrated into e.g. an Autotools project:
+
 ```bash
-AM_CXXFLAGS = -std=c++17 -pedantic -W -Wall @SDBUSCPP_CFLAGS@ ...
-AM_LDFLAGS = @SDBUSCPP_LIBS@ ...
+PKG_CHECK_MODULES(SDBUSCPP, [sdbus-c++ >= 0.4],,
+    AC_MSG_ERROR([You need the sdbus-c++ library (version 0.4 or newer)]
+    [http://www.kistler.com/])
+)
 ```
 
 Note: sdbus-c++ library depends on C++17, since it uses C++17 `std::uncaught_exceptions()` feature. When building sdbus-c++ manually, make sure you use a compiler that supports that feature. To use the library, make sure you have a C++ standard library that supports the feature. The feature is supported by e.g. gcc >= 6, and clang >= 3.7.
@@ -258,9 +256,15 @@ int main(int argc, char *argv[])
 }
 ```
 
-The object proxy can be created by either explicitly passing the connection object to it, or without the connection object. In the former case, we have the freedom of creating our own connection (to either system bus or to session bus) and then we can just move that connection object as the first argument of the proxy factory. The latter option is more convenient (no messing with connection for proxy), the proxy will create and manage its own connection, but the limitation is that it will be the connection to the **system** bus only.
+### Proxy and D-Bus connection
 
-If there are callbacks for signals, proxy will start listening to the signals upon the connection in a separate thread. That means the `onConcatenated` method is invoked always in the context of a thread different from the main thread.
+There are three ways of creating the object proxy -- three overloads of `sdbus::createObjectProxy`. They differ from each other as to how the proxy towards the connection will behave upon creation:
+
+* One that takes no connection as a parameter. This one is for convenience -- if you have a simple application and don't want to bother with connections, call this one. Internally, it will create a connection object, and it will be a *system* bus connection. The proxy will immediately create an internal thread and start a processing loop upon the clone of this connection in this thread as long as there is at least one signal registered, so the signals are correctly received and the callbacks are handled from within this internal thread. If there is no signal, i.e. the proxy just provides methods and/or properties, no connection clone is made, no thread is created and no processing loop is started -- you don't pay for what you don't use.
+
+* One that takes the connection as an **rvalue unique_ptr**. This one behaves the same as the above one, just that you must create the connection by yourself, and then `std::move` the ownership of it to the proxy. This comes with a flexibility that you can choose connection type (system, session).
+
+* One that takes the connection as an **lvalue reference**. This one behaves differently. You as a client are the owner of the connection, you take full control of it. The proxy just references the connection. This means the proxy does no async processing on it even when there are signals. It relies on you to manage the processing loop yourself (if you need it for signals).
 
 Implementing the Concatenator example using convenience sdbus-c++ API layer
 ---------------------------------------------------------------------------
@@ -632,6 +636,8 @@ protected:
 
 In the above example, a proxy is created that creates and maintains its own system bus connection. However, there are `ProxyInterfaces` class template constructor overloads that also take the connection from the user as the first parameter, and pass that connection over to the underlying proxy. The connection instance is used for all D-Bus proxy interfaces listed in the `ProxyInterfaces` template parameter list.
 
+Note however that there are multiple `ProxyInterfaces` constructor overloads, and they differ in how the proxy behaves towards the D-Bus connection. These overloads precisely map the `sdbus::createObjectProxy` overloads, as they are actually implemented on top of them. See [Proxy and D-Bus connection](#Proxy-and-D-Bus-connection) for more info.
+
 Now let's use this proxy to make remote calls and listen to signals in a real application.
 
 ```cpp

include/sdbus-c++/ConvenienceClasses.h

@@ -28,6 +28,7 @@
 
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/TypeTraits.h>
+#include <sdbus-c++/Flags.h>
 #include <string>
 #include <type_traits>
 
@@ -44,16 +45,29 @@ 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);
         template <typename _Function>
-        std::enable_if_t<!is_async_method_v<_Function>> implementedAs(_Function&& callback);
+        std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
         template <typename _Function>
-        std::enable_if_t<is_async_method_v<_Function>> implementedAs(_Function&& callback);
+        std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
+        MethodRegistrator& markAsDeprecated();
+        MethodRegistrator& markAsPrivileged();
+        MethodRegistrator& withNoReply();
 
     private:
         IObject& object_;
         const std::string& methodName_;
         std::string interfaceName_;
+        std::string inputSignature_;
+        std::string outputSignature_;
+        method_callback syncCallback_;
+        async_method_callback asyncCallback_;
+        Flags flags_;
+        int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
     };
 
     class SignalRegistrator
@@ -63,14 +77,17 @@ namespace sdbus {
         SignalRegistrator(SignalRegistrator&& other) = default;
         SignalRegistrator& operator=(SignalRegistrator&& other) = default;
         ~SignalRegistrator() noexcept(false);
+
         SignalRegistrator& onInterface(std::string interfaceName);
-        template <typename... _Args> void withParameters();
+        template <typename... _Args> SignalRegistrator& withParameters();
+        SignalRegistrator& markAsDeprecated();
 
     private:
         IObject& object_;
         const std::string& signalName_;
         std::string interfaceName_;
         std::string signalSignature_;
+        Flags flags_;
         int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
     };
 
@@ -81,9 +98,13 @@ namespace sdbus {
         PropertyRegistrator(PropertyRegistrator&& other) = default;
         PropertyRegistrator& operator=(PropertyRegistrator&& other) = default;
         ~PropertyRegistrator() noexcept(false);
+
         PropertyRegistrator& onInterface(const std::string& interfaceName);
         template <typename _Function> PropertyRegistrator& withGetter(_Function&& callback);
         template <typename _Function> PropertyRegistrator& withSetter(_Function&& callback);
+        PropertyRegistrator& markAsDeprecated();
+        PropertyRegistrator& markAsPrivileged();
+        PropertyRegistrator& withUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior);
 
     private:
         IObject& object_;
@@ -92,9 +113,30 @@ namespace sdbus {
         std::string propertySignature_;
         property_get_callback getter_;
         property_set_callback setter_;
+        Flags flags_;
         int exceptions_{}; // Number of active exceptions when PropertyRegistrator is constructed
     };
 
+    class InterfaceFlagsSetter
+    {
+    public:
+        InterfaceFlagsSetter(IObject& object, const std::string& interfaceName);
+        InterfaceFlagsSetter(InterfaceFlagsSetter&& other) = default;
+        InterfaceFlagsSetter& operator=(InterfaceFlagsSetter&& other) = default;
+        ~InterfaceFlagsSetter() noexcept(false);
+
+        InterfaceFlagsSetter& markAsDeprecated();
+        InterfaceFlagsSetter& markAsPrivileged();
+        InterfaceFlagsSetter& withNoReplyMethods();
+        InterfaceFlagsSetter& withPropertyUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior);
+
+    private:
+        IObject& object_;
+        const std::string& interfaceName_;
+        Flags flags_;
+        int exceptions_{}; // Number of active exceptions when InterfaceFlagsSetter is constructed
+    };
+
     class SignalEmitter
     {
     public:
@@ -123,6 +165,7 @@ namespace sdbus {
         MethodInvoker& onInterface(const std::string& interfaceName);
         template <typename... _Args> MethodInvoker& withArguments(_Args&&... args);
         template <typename... _Args> void storeResultsTo(_Args&... args);
+        void dontExpectReply();
 
     private:
         IObjectProxy& objectProxy_;

include/sdbus-c++/ConvenienceClasses.inl

@@ -39,12 +39,41 @@
 
 namespace sdbus {
 
+    // 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
     {
     }
 
+    inline 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);
+
+        // 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.
+        if (syncCallback_)
+            object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(syncCallback_));
+        else if(asyncCallback_)
+            object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(asyncCallback_));
+        else
+            SDBUS_THROW_ERROR("Method handler not specified when registering a DBus method", EINVAL);
+    }
+    */
+
     inline MethodRegistrator& MethodRegistrator::onInterface(const std::string& interfaceName)
     {
         interfaceName_ = interfaceName;
@@ -53,15 +82,11 @@ namespace sdbus {
     }
 
     template <typename _Function>
-    inline std::enable_if_t<!is_async_method_v<_Function>> MethodRegistrator::implementedAs(_Function&& callback)
+    inline std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> MethodRegistrator::implementedAs(_Function&& callback)
     {
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);
-
-        object_.registerMethod( interfaceName_
-                              , methodName_
-                              , signature_of_function_input_arguments<_Function>::str()
-                              , signature_of_function_output_arguments<_Function>::str()
-                              , [callback = std::forward<_Function>(callback)](MethodCall& msg, MethodReply& reply)
+        inputSignature_ = signature_of_function_input_arguments<_Function>::str();
+        outputSignature_ = signature_of_function_output_arguments<_Function>::str();
+        syncCallback_ = [callback = std::forward<_Function>(callback)](MethodCall& msg, MethodReply& reply)
         {
             // Create a tuple of callback input arguments' types, which will be used
             // as a storage for the argument values deserialized from the message.
@@ -78,19 +103,17 @@ namespace sdbus {
             // The return value is stored to the reply message.
             // In case of void functions, ret is an empty tuple and thus nothing is stored.
             reply << ret;
-        });
+        };
+
+        return *this;
     }
 
     template <typename _Function>
-    inline std::enable_if_t<is_async_method_v<_Function>> MethodRegistrator::implementedAs(_Function&& callback)
+    inline std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&> MethodRegistrator::implementedAs(_Function&& callback)
     {
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);
-
-        object_.registerMethod( interfaceName_
-                              , methodName_
-                              , signature_of_function_input_arguments<_Function>::str()
-                              , signature_of_function_output_arguments<_Function>::str() //signature_of<last_function_argument_t<_Function>>::str() // because last argument contains output types
-                              , [callback = std::forward<_Function>(callback)](MethodCall& msg, MethodResult result)
+        inputSignature_ = signature_of_function_input_arguments<_Function>::str();
+        outputSignature_ = signature_of_function_output_arguments<_Function>::str();
+        asyncCallback_ = [callback = std::forward<_Function>(callback)](MethodCall& msg, MethodResult result)
         {
             // Create a tuple of callback input arguments' types, which will be used
             // as a storage for the argument values deserialized from the message.
@@ -102,9 +125,33 @@ namespace sdbus {
 
             // Invoke callback with input arguments from the tuple.
             sdbus::apply(callback, std::move(result), inputArgs); // TODO: Use std::apply when switching to full C++17 support
-        });
+        };
+
+        return *this;
     }
 
+    inline MethodRegistrator& MethodRegistrator::markAsDeprecated()
+    {
+        flags_.set(Flags::DEPRECATED);
+
+        return *this;
+    }
+
+    inline MethodRegistrator& MethodRegistrator::markAsPrivileged()
+    {
+        flags_.set(Flags::PRIVILEGED);
+
+        return *this;
+    }
+
+    inline MethodRegistrator& MethodRegistrator::withNoReply()
+    {
+        flags_.set(Flags::METHOD_NO_REPLY);
+
+        return *this;
+    }
+
+
     // Moved into the library to isolate from C++17 dependency
     /*
     inline SignalRegistrator::SignalRegistrator(IObject& object, std::string signalName)
@@ -144,9 +191,18 @@ namespace sdbus {
     }
 
     template <typename... _Args>
-    inline void SignalRegistrator::withParameters()
+    inline SignalRegistrator& SignalRegistrator::withParameters()
     {
         signalSignature_ = signature_of_function_input_arguments<void(_Args...)>::str();
+
+        return *this;
+    }
+
+    inline SignalRegistrator& SignalRegistrator::markAsDeprecated()
+    {
+        flags_.set(Flags::DEPRECATED);
+
+        return *this;
     }
 
 
@@ -234,6 +290,87 @@ namespace sdbus {
         return *this;
     }
 
+    inline PropertyRegistrator& PropertyRegistrator::markAsDeprecated()
+    {
+        flags_.set(Flags::DEPRECATED);
+
+        return *this;
+    }
+
+    inline PropertyRegistrator& PropertyRegistrator::markAsPrivileged()
+    {
+        flags_.set(Flags::PRIVILEGED);
+
+        return *this;
+    }
+
+    inline PropertyRegistrator& PropertyRegistrator::withUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior)
+    {
+        flags_.set(behavior);
+
+        return *this;
+    }
+
+
+    // Moved into the library to isolate from C++17 dependency
+    /*
+    inline InterfaceFlagsSetter::InterfaceFlagsSetter(IObject& object, const std::string& interfaceName)
+        : object_(object)
+        , interfaceName_(interfaceName)
+        , exceptions_(std::uncaught_exceptions())
+    {
+    }
+
+    inline 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_) );
+    }
+    */
+
+    inline InterfaceFlagsSetter& InterfaceFlagsSetter::markAsDeprecated()
+    {
+        flags_.set(Flags::DEPRECATED);
+
+        return *this;
+    }
+
+    inline InterfaceFlagsSetter& InterfaceFlagsSetter::markAsPrivileged()
+    {
+        flags_.set(Flags::PRIVILEGED);
+
+        return *this;
+    }
+
+    inline InterfaceFlagsSetter& InterfaceFlagsSetter::withNoReplyMethods()
+    {
+        flags_.set(Flags::METHOD_NO_REPLY);
+
+        return *this;
+    }
+
+    inline InterfaceFlagsSetter& InterfaceFlagsSetter::withPropertyUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior)
+    {
+        flags_.set(behavior);
+
+        return *this;
+    }
+
 
     // Moved into the library to isolate from C++17 dependency
     /*
@@ -342,6 +479,13 @@ namespace sdbus {
         detail::deserialize_pack(reply, args...);
     }
 
+    inline void MethodInvoker::dontExpectReply()
+    {
+        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+
+        method_.dontExpectReply();
+    }
+
 
     inline SignalSubscriber::SignalSubscriber(IObjectProxy& objectProxy, const std::string& signalName)
         : objectProxy_(objectProxy)

include/sdbus-c++/Flags.h

@@ -0,0 +1,98 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Flags.h
+ *
+ * Created on: Dec 31, 2018
+ * 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/>.
+ */
+
+#ifndef SDBUS_CXX_FLAGS_H_
+#define SDBUS_CXX_FLAGS_H_
+
+#include <bitset>
+#include <cstdint>
+
+namespace sdbus {
+
+    // D-Bus interface, method, signal or property flags
+    class Flags
+    {
+    public:
+        enum GeneralFlags : uint8_t
+        {    DEPRECATED = 0
+        ,    METHOD_NO_REPLY = 1
+        ,    PRIVILEGED = 2
+        };
+
+        enum PropertyUpdateBehaviorFlags : uint8_t
+        {   EMITS_CHANGE_SIGNAL = 3
+        ,   EMITS_INVALIDATION_SIGNAL = 4
+        ,   EMITS_NO_SIGNAL = 5
+        ,   CONST_PROPERTY_VALUE = 6
+        };
+
+        enum : uint8_t
+        {   FLAG_COUNT = 7
+        };
+
+        Flags()
+        {
+            // EMITS_CHANGE_SIGNAL is on by default
+            flags_.set(EMITS_CHANGE_SIGNAL, true);
+        }
+
+        void set(GeneralFlags flag, bool value = true)
+        {
+            flags_.set(flag, value);
+        }
+
+        void set(PropertyUpdateBehaviorFlags flag, bool value = true)
+        {
+            flags_.set(EMITS_CHANGE_SIGNAL, false);
+            flags_.set(EMITS_INVALIDATION_SIGNAL, false);
+            flags_.set(EMITS_NO_SIGNAL, false);
+            flags_.set(CONST_PROPERTY_VALUE, false);
+
+            flags_.set(flag, value);
+        }
+
+        bool test(GeneralFlags flag) const
+        {
+            return flags_.test(flag);
+        }
+
+        bool test(PropertyUpdateBehaviorFlags flag) const
+        {
+            return flags_.test(flag);
+        }
+
+        uint64_t toSdBusInterfaceFlags() const;
+        uint64_t toSdBusMethodFlags() const;
+        uint64_t toSdBusSignalFlags() const;
+        uint64_t toSdBusPropertyFlags() const;
+        uint64_t toSdBusWritablePropertyFlags() const;
+
+    private:
+        std::bitset<FLAG_COUNT> flags_;
+    };
+    
+}
+
+#endif /* SDBUS_CXX_FLAGS_H_ */

include/sdbus-c++/IObject.h

@@ -28,6 +28,7 @@
 
 #include <sdbus-c++/ConvenienceClasses.h>
 #include <sdbus-c++/TypeTraits.h>
+#include <sdbus-c++/Flags.h>
 #include <functional>
 #include <string>
 #include <memory>
@@ -61,6 +62,7 @@ namespace sdbus {
         * @param[in] inputSignature D-Bus signature of method input parameters
         * @param[in] outputSignature D-Bus signature of method output parameters
         * @param[in] methodCallback Callback that implements the body of the method
+        * @param[in] noReply If true, the method isn't expected to send reply
         *
         * @throws sdbus::Error in case of failure
         */
@@ -68,7 +70,8 @@ namespace sdbus {
                                    , const std::string& methodName
                                    , const std::string& inputSignature
                                    , const std::string& outputSignature
-                                   , method_callback methodCallback ) = 0;
+                                   , method_callback methodCallback
+                                   , Flags flags = {} ) = 0;
 
         /*!
         * @brief Registers method that the object will provide on D-Bus
@@ -78,6 +81,7 @@ namespace sdbus {
         * @param[in] inputSignature D-Bus signature of method input parameters
         * @param[in] outputSignature D-Bus signature of method output parameters
         * @param[in] asyncMethodCallback Callback that implements the body of the method
+        * @param[in] noReply If true, the method isn't expected to send reply
         *
         * This overload register a method callback that will have a freedom to execute
         * its body in asynchronous contexts, and send the results from those contexts.
@@ -90,7 +94,8 @@ namespace sdbus {
                                    , const std::string& methodName
                                    , const std::string& inputSignature
                                    , const std::string& outputSignature
-                                   , async_method_callback asyncMethodCallback ) = 0;
+                                   , async_method_callback asyncMethodCallback
+                                   , Flags flags = {} ) = 0;
 
         /*!
         * @brief Registers signal that the object will emit on D-Bus
@@ -103,7 +108,8 @@ namespace sdbus {
         */
         virtual void registerSignal( const std::string& interfaceName
                                    , const std::string& signalName
-                                   , const std::string& signature ) = 0;
+                                   , const std::string& signature
+                                   , Flags flags = {} ) = 0;
 
         /*!
         * @brief Registers read-only property that the object will provide on D-Bus
@@ -118,7 +124,8 @@ namespace sdbus {
         virtual void registerProperty( const std::string& interfaceName
                                      , const std::string& propertyName
                                      , const std::string& signature
-                                     , property_get_callback getCallback ) = 0;
+                                     , property_get_callback getCallback
+                                     , Flags flags = {} ) = 0;
 
         /*!
         * @brief Registers read/write property that the object will provide on D-Bus
@@ -135,7 +142,18 @@ namespace sdbus {
                                      , const std::string& propertyName
                                      , const std::string& signature
                                      , property_get_callback getCallback
-                                     , property_set_callback setCallback ) = 0;
+                                     , property_set_callback setCallback
+                                     , Flags flags = {} ) = 0;
+
+        /*!
+        * @brief Sets flags for a given interface
+        *
+        * @param[in] interfaceName Name of an interface whose flags will be set
+        * @param[in] flags Flags to be set
+        *
+        * @throws sdbus::Error in case of failure
+        */
+        virtual void setInterfaceFlags(const std::string& interfaceName, Flags flags) = 0;
 
         /*!
         * @brief Finishes the registration and exports object API on D-Bus
@@ -231,6 +249,23 @@ namespace sdbus {
         */
         PropertyRegistrator registerProperty(const std::string& propertyName);
 
+        /*!
+        * @brief Sets flags (annotations) for a given interface
+        *
+        * @param[in] interfaceName Name of an interface whose flags will be set
+        * @return A helper object for convenient setting of Interface flags
+        *
+        * This is a high-level, convenience alternative to the other setInterfaceFlags overload.
+        *
+        * Example of use:
+        * @code
+        * object_.setInterfaceFlags("com.kistler.foo").markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
+        * @endcode
+        *
+        * @throws sdbus::Error in case of failure
+        */
+        InterfaceFlagsSetter setInterfaceFlags(const std::string& interfaceName);
+
         /*!
         * @brief Emits signal on D-Bus
         *
@@ -270,6 +305,11 @@ namespace sdbus {
         return PropertyRegistrator(*this, std::move(propertyName));
     }
 
+    inline InterfaceFlagsSetter IObject::setInterfaceFlags(const std::string& interfaceName)
+    {
+        return InterfaceFlagsSetter(*this, std::move(interfaceName));
+    }
+
     inline SignalEmitter IObject::emitSignal(const std::string& signalName)
     {
         return SignalEmitter(*this, signalName);

include/sdbus-c++/IObjectProxy.h

@@ -72,6 +72,14 @@ namespace sdbus {
         * @brief Calls method on the proxied D-Bus object
         *
         * @param[in] message Message representing a method call
+        * @return A method reply message
+        *
+        * Normally, the call is blocking, i.e. it waits for the remote method to finish with either
+        * a return value or an error.
+        *
+        * If the method call argument is set to not expect reply, the call will not wait for the remote
+        * method to finish, i.e. the call will be non-blocking, and the function will return an empty,
+        * invalid MethodReply object (representing void).
         *
         * Note: To avoid messing with messages, use higher-level API defined below.
         *
@@ -215,7 +223,11 @@ namespace sdbus {
     * @return Pointer to the object proxy instance
     *
     * The provided connection will be used by the proxy to issue calls against the object,
-    * and signals, if any, will be subscribed to on this connection.
+    * and signals, if any, will be subscribed to on this connection. Since the caller still
+    * remains the owner of the connection (the proxy just keeps reference to it) after the call,
+    * the proxy will not start its own background processing loop for incoming signals (if any),
+    * as it will rely on the client as an owner of the connection to handle processing of
+    * incoming messages on that connection by themselves.
     *
     * Code example:
     * @code
@@ -236,7 +248,10 @@ namespace sdbus {
     *
     * The provided connection will be used by the proxy to issue calls against the object,
     * and signals, if any, will be subscribed to on this connection. Object proxy becomes
-    * an exclusive owner of this connection.
+    * an exclusive owner of this connection. The effect of this is that when there is at
+    * least one signal in proxy's interface, then the proxy will immediately start its own
+    * processing loop for this connection in a separate internal thread, causing incoming
+    * signals to be correctly received and processed in the context of that internal thread.
     *
     * Code example:
     * @code
@@ -255,6 +270,9 @@ namespace sdbus {
     * @return Pointer to the object proxy instance
     *
     * This factory overload creates a proxy that manages its own D-Bus connection(s).
+    * When there is at least one signal in proxy's interface, then the proxy will immediately
+    * start its own processing loop for this connection in its own separate thread, causing
+    * incoming signals to be correctly received and processed in the context of that thread.
     *
     * Code example:
     * @code

include/sdbus-c++/Interfaces.h

@@ -100,6 +100,15 @@ namespace sdbus {
         , public _Interfaces...
     {
     public:
+        /*!
+        * @brief Creates fully working object proxy instance
+        *
+        * @param[in] destination Bus name that provides a D-Bus object
+        * @param[in] objectPath Path of the D-Bus object
+        *
+        * This constructor overload creates a proxy that manages its own D-Bus connection(s).
+        * For more information on its behavior, consult @ref createObjectProxy(std::string, std::string)
+        */
         ProxyInterfaces(std::string destination, std::string objectPath)
             : ObjectHolder<IObjectProxy>(createObjectProxy(std::move(destination), std::move(objectPath)))
             , _Interfaces(getObject())...
@@ -107,6 +116,16 @@ namespace sdbus {
             getObject().finishRegistration();
         }
 
+        /*!
+        * @brief Creates fully working object proxy instance
+        *
+        * @param[in] connection D-Bus connection to be used by the proxy object
+        * @param[in] destination Bus name that provides a D-Bus object
+        * @param[in] objectPath Path of the D-Bus object
+        *
+        * The proxy created this way just references a D-Bus connection owned and managed by the user.
+        * For more information on its behavior, consult @ref createObjectProxy(IConnection&,std::string, std::string)
+        */
         ProxyInterfaces(IConnection& connection, std::string destination, std::string objectPath)
             : ObjectHolder<IObjectProxy>(createObjectProxy(connection, std::move(destination), std::move(objectPath)))
             , _Interfaces(getObject())...
@@ -114,13 +133,22 @@ namespace sdbus {
             getObject().finishRegistration();
         }
 
+        /*!
+        * @brief Creates fully working object proxy instance
+        *
+        * @param[in] connection D-Bus connection to be used by the proxy object
+        * @param[in] destination Bus name that provides a D-Bus object
+        * @param[in] objectPath Path of the D-Bus object
+        *
+        * The proxy created this way becomes an owner of the connection.
+        * For more information on its behavior, consult @ref createObjectProxy(std::unique_ptr<sdbus::IConnection>&&,std::string, std::string)
+        */
         ProxyInterfaces(std::unique_ptr<sdbus::IConnection>&& connection, std::string destination, std::string objectPath)
             : ObjectHolder<IObjectProxy>(createObjectProxy(std::move(connection), std::move(destination), std::move(objectPath)))
             , _Interfaces(getObject())...
         {
             getObject().finishRegistration();
         }
-        
     };
 
 }

include/sdbus-c++/Message.h

@@ -155,6 +155,12 @@ namespace sdbus {
         MethodReply send() const;
         MethodReply createReply() const;
         MethodReply createErrorReply(const sdbus::Error& error) const;
+        void dontExpectReply();
+        bool doesntExpectReply() const;
+
+    private:
+        MethodReply sendWithReply() const;
+        MethodReply sendWithNoReply() const;
     };
 
     class MethodReply : public Message

include/sdbus-c++/Types.h

@@ -140,6 +140,9 @@ namespace sdbus {
     public:
         using std::string::string;
         using std::string::operator=;
+        ObjectPath(std::string path)
+            : std::string(std::move(path))
+        {}
     };
 
     class Signature : public std::string
@@ -147,6 +150,9 @@ namespace sdbus {
     public:
         using std::string::string;
         using std::string::operator=;
+        Signature(std::string path)
+            : std::string(std::move(path))
+        {}
     };
 
 }

sdbus-c++-config-version.cmake.in

@@ -1,11 +0,0 @@
-set(PACKAGE_VERSION "@SDBUSCPP_VERSION@")
-
-# Check whether the requested PACKAGE_FIND_VERSION is compatible
-if("${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}")
-  set(PACKAGE_VERSION_COMPATIBLE FALSE)
-else()
-  set(PACKAGE_VERSION_COMPATIBLE TRUE)
-  if ("${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}")
-    set(PACKAGE_VERSION_EXACT TRUE)
-  endif()
-endif()

src/Connection.cpp

@@ -24,6 +24,7 @@
  */
 
 #include "Connection.h"
+#include "SdBus.h"
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/Error.h>
 #include "ScopeGuard.h"
@@ -34,8 +35,9 @@
 
 namespace sdbus { namespace internal {
 
-Connection::Connection(Connection::BusType type)
+Connection::Connection(Connection::BusType type, std::unique_ptr<ISdBus>&& interface)
     : busType_(type)
+    , iface_(std::move(interface))
 {
     auto bus = openBus(busType_);
     bus_.reset(bus);
@@ -53,13 +55,13 @@ Connection::~Connection()
 
 void Connection::requestName(const std::string& name)
 {
-    auto r = sd_bus_request_name(bus_.get(), name.c_str(), 0);
+    auto r = iface_->sd_bus_request_name(bus_.get(), name.c_str(), 0);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to request bus name", -r);
 }
 
 void Connection::releaseName(const std::string& name)
 {
-    auto r = sd_bus_release_name(bus_.get(), name.c_str());
+    auto r = iface_->sd_bus_release_name(bus_.get(), name.c_str());
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to release bus name", -r);
 }
 
@@ -90,28 +92,28 @@ void Connection::leaveProcessingLoop()
     joinWithProcessingLoop();
 }
 
-void* Connection::addObjectVTable( const std::string& objectPath
-                                 , const std::string& interfaceName
-                                 , const void* vtable
-                                 , void* userData )
+sd_bus_slot* Connection::addObjectVTable( const std::string& objectPath
+                                        , const std::string& interfaceName
+                                        , const sd_bus_vtable* vtable
+                                        , void* userData )
 {
     sd_bus_slot *slot{};
 
-    auto r = sd_bus_add_object_vtable( bus_.get()
-                                     , &slot
-                                     , objectPath.c_str()
-                                     , interfaceName.c_str()
-                                     , static_cast<const sd_bus_vtable*>(vtable)
-                                     , userData );
+    auto r = iface_->sd_bus_add_object_vtable( bus_.get()
+                                             , &slot
+                                             , objectPath.c_str()
+                                             , interfaceName.c_str()
+                                             , vtable
+                                             , userData );
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to register object vtable", -r);
 
     return slot;
 }
 
-void Connection::removeObjectVTable(void* vtableHandle)
+void Connection::removeObjectVTable(sd_bus_slot* vtableHandle)
 {
-    sd_bus_slot_unref((sd_bus_slot *)vtableHandle);
+    iface_->sd_bus_slot_unref(vtableHandle);
 }
 
 sdbus::MethodCall Connection::createMethodCall( const std::string& destination
@@ -122,14 +124,14 @@ sdbus::MethodCall Connection::createMethodCall( const std::string& destination
     sd_bus_message *sdbusMsg{};
 
     // Returned message will become an owner of sdbusMsg
-    SCOPE_EXIT{ sd_bus_message_unref(sdbusMsg); };
+    SCOPE_EXIT{ iface_->sd_bus_message_unref(sdbusMsg); };
 
-    auto r = sd_bus_message_new_method_call( bus_.get()
-                                           , &sdbusMsg
-                                           , destination.c_str()
-                                           , objectPath.c_str()
-                                           , interfaceName.c_str()
-                                           , methodName.c_str() );
+    auto r = iface_->sd_bus_message_new_method_call( bus_.get()
+                                                   , &sdbusMsg
+                                                   , destination.c_str()
+                                                   , objectPath.c_str()
+                                                   , interfaceName.c_str()
+                                                   , methodName.c_str() );
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method call", -r);
 
@@ -143,38 +145,38 @@ sdbus::Signal Connection::createSignal( const std::string& objectPath
     sd_bus_message *sdbusSignal{};
 
     // Returned message will become an owner of sdbusSignal
-    SCOPE_EXIT{ sd_bus_message_unref(sdbusSignal); };
+    SCOPE_EXIT{ iface_->sd_bus_message_unref(sdbusSignal); };
 
-    auto r = sd_bus_message_new_signal( bus_.get()
-                                      , &sdbusSignal
-                                      , objectPath.c_str()
-                                      , interfaceName.c_str()
-                                      , signalName.c_str() );
+    auto r = iface_->sd_bus_message_new_signal( bus_.get()
+                                              , &sdbusSignal
+                                              , objectPath.c_str()
+                                              , interfaceName.c_str()
+                                              , signalName.c_str() );
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to create signal", -r);
 
     return Signal(sdbusSignal);
 }
 
-void* Connection::registerSignalHandler( const std::string& objectPath
-                                       , const std::string& interfaceName
-                                       , const std::string& signalName
-                                       , sd_bus_message_handler_t callback
-                                       , void* userData )
+sd_bus_slot* Connection::registerSignalHandler( const std::string& objectPath
+                                              , const std::string& interfaceName
+                                              , const std::string& signalName
+                                              , sd_bus_message_handler_t callback
+                                              , void* userData )
 {
     sd_bus_slot *slot{};
 
     auto filter = composeSignalMatchFilter(objectPath, interfaceName, signalName);
-    auto r = sd_bus_add_match(bus_.get(), &slot, filter.c_str(), callback, userData);
+    auto r = iface_->sd_bus_add_match(bus_.get(), &slot, filter.c_str(), callback, userData);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to register signal handler", -r);
 
     return slot;
 }
 
-void Connection::unregisterSignalHandler(void* handlerCookie)
+void Connection::unregisterSignalHandler(sd_bus_slot* handlerCookie)
 {
-    sd_bus_slot_unref((sd_bus_slot *)handlerCookie);
+    iface_->sd_bus_slot_unref(handlerCookie);
 }
 
 void Connection::sendReplyAsynchronously(const sdbus::MethodReply& reply)
@@ -186,20 +188,21 @@ void Connection::sendReplyAsynchronously(const sdbus::MethodReply& reply)
 
 std::unique_ptr<sdbus::internal::IConnection> Connection::clone() const
 {
-    return std::make_unique<sdbus::internal::Connection>(busType_);
+    auto interface = std::make_unique<SdBus>();
+    assert(interface != nullptr);
+    return std::make_unique<sdbus::internal::Connection>(busType_, std::move(interface));
 }
 
 sd_bus* Connection::openBus(Connection::BusType type)
 {
-    static std::map<sdbus::internal::Connection::BusType, int(*)(sd_bus **)> busTypeToFactory
-    {
-        {sdbus::internal::Connection::BusType::eSystem, &sd_bus_open_system},
-        {sdbus::internal::Connection::BusType::eSession, &sd_bus_open_user}
-    };
-
     sd_bus* bus{};
-
-    auto r = busTypeToFactory[type](&bus);
+    int r = 0;
+    if (type == BusType::eSystem)
+        r = iface_->sd_bus_open_system(&bus);
+    else if (type == BusType::eSession)
+        r = iface_->sd_bus_open_user(&bus);
+    else
+        assert(false);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to open bus", -r);
     assert(bus != nullptr);
@@ -215,7 +218,7 @@ void Connection::finishHandshake(sd_bus* bus)
 
     assert(bus != nullptr);
 
-    auto r = sd_bus_flush(bus);
+    auto r = iface_->sd_bus_flush(bus);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to flush bus on opening", -r);
 }
@@ -263,7 +266,7 @@ bool Connection::processPendingRequest()
 
     assert(bus != nullptr);
 
-    int r = sd_bus_process(bus, nullptr);
+    int r = iface_->sd_bus_process(bus, nullptr);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to process bus requests", -r);
 
@@ -288,16 +291,16 @@ Connection::WaitResult Connection::waitForNextRequest()
     assert(bus != nullptr);
     assert(notificationFd_ != 0);
 
-    auto r = sd_bus_get_fd(bus);
+    auto r = iface_->sd_bus_get_fd(bus);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus descriptor", -r);
     auto sdbusFd = r;
 
-    r = sd_bus_get_events(bus);
+    r = iface_->sd_bus_get_events(bus);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus events", -r);
     short int sdbusEvents = r;
 
     uint64_t usec;
-    sd_bus_get_timeout(bus, &usec);
+    iface_->sd_bus_get_timeout(bus, &usec);
 
     struct pollfd fds[] = {{sdbusFd, sdbusEvents, 0}, {notificationFd_, POLLIN, 0}};
     auto fdsCount = sizeof(fds)/sizeof(fds[0]);
@@ -356,7 +359,10 @@ std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name)
 
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection()
 {
-    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSystem);
+    auto interface = std::make_unique<sdbus::internal::SdBus>();
+    assert(interface != nullptr);
+    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSystem,
+                                                         std::move(interface));
 }
 
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name)
@@ -368,7 +374,10 @@ std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string&
 
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection()
 {
-    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSession);
+    auto interface = std::make_unique<sdbus::internal::SdBus>();
+    assert(interface != nullptr);
+    return std::make_unique<sdbus::internal::Connection>(sdbus::internal::Connection::BusType::eSession,
+                                                         std::move(interface));
 }
 
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name)

src/Connection.h

@@ -29,6 +29,8 @@
 #include <sdbus-c++/IConnection.h>
 #include <sdbus-c++/Message.h>
 #include "IConnection.h"
+#include "ISdBus.h"
+
 #include <systemd/sd-bus.h>
 #include <memory>
 #include <thread>
@@ -49,8 +51,8 @@ namespace sdbus { namespace internal {
             eSession
         };
 
-        Connection(BusType type);
-        ~Connection();
+        Connection(BusType type, std::unique_ptr<ISdBus>&& interface);
+        ~Connection() override;
 
         void requestName(const std::string& name) override;
         void releaseName(const std::string& name) override;
@@ -58,11 +60,11 @@ namespace sdbus { namespace internal {
         void enterProcessingLoopAsync() override;
         void leaveProcessingLoop() override;
 
-        void* addObjectVTable( const std::string& objectPath
-                             , const std::string& interfaceName
-                             , const void* vtable
-                             , void* userData ) override;
-        void removeObjectVTable(void* vtableHandle) override;
+        sd_bus_slot* addObjectVTable( const std::string& objectPath
+                                    , const std::string& interfaceName
+                                    , const sd_bus_vtable* vtable
+                                    , void* userData ) override;
+        void removeObjectVTable(sd_bus_slot* vtableHandle) override;
 
         sdbus::MethodCall createMethodCall( const std::string& destination
                                           , const std::string& objectPath
@@ -72,12 +74,12 @@ namespace sdbus { namespace internal {
                                   , const std::string& interfaceName
                                   , const std::string& signalName ) const override;
 
-        void* registerSignalHandler( const std::string& objectPath
-                                   , const std::string& interfaceName
-                                   , const std::string& signalName
-                                   , sd_bus_message_handler_t callback
-                                   , void* userData ) override;
-        void unregisterSignalHandler(void* handlerCookie) override;
+        sd_bus_slot* registerSignalHandler( const std::string& objectPath
+                                          , const std::string& interfaceName
+                                          , const std::string& signalName
+                                          , sd_bus_message_handler_t callback
+                                          , void* userData ) override;
+        void unregisterSignalHandler(sd_bus_slot* handlerCookie) override;
 
         void sendReplyAsynchronously(const sdbus::MethodReply& reply) override;
 
@@ -93,8 +95,8 @@ namespace sdbus { namespace internal {
                 return msgsToProcess || asyncMsgsToProcess;
             }
         };
-        static sd_bus* openBus(Connection::BusType type);
-        static void finishHandshake(sd_bus* bus);
+        sd_bus* openBus(Connection::BusType type);
+        void finishHandshake(sd_bus* bus);
         static int createLoopNotificationDescriptor();
         static void closeLoopNotificationDescriptor(int fd);
         bool processPendingRequest();
@@ -108,7 +110,11 @@ namespace sdbus { namespace internal {
         void joinWithProcessingLoop();
 
     private:
-        std::unique_ptr<sd_bus, decltype(&sd_bus_flush_close_unref)> bus_{nullptr, &sd_bus_flush_close_unref};
+        std::unique_ptr<ISdBus> iface_;
+        std::unique_ptr<sd_bus, std::function<sd_bus*(sd_bus*)>> bus_ {nullptr, [this](sd_bus* bus)
+                                                                                {
+                                                                                    return iface_->sd_bus_flush_close_unref(bus);
+                                                                                }};
         std::thread asyncLoopThread_;
         std::mutex mutex_;
         std::queue<MethodReply> asyncReplies_;

src/ConvenienceClasses.cpp

@@ -31,6 +31,38 @@
 
 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);
+
+    // 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.
+    if (syncCallback_)
+        object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(syncCallback_), flags_);
+    else if(asyncCallback_)
+        object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(asyncCallback_), flags_);
+    else
+        SDBUS_THROW_ERROR("Method handler not specified when registering a DBus method", EINVAL);
+}
+
 SignalRegistrator::SignalRegistrator(IObject& object, const std::string& signalName)
     : object_(object)
     , signalName_(signalName)
@@ -55,7 +87,7 @@ SignalRegistrator::~SignalRegistrator() noexcept(false) // since C++11, destruct
     // 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_);
 }
 
 
@@ -87,7 +119,37 @@ PropertyRegistrator::~PropertyRegistrator() noexcept(false) // since C++11, dest
                             , std::move(propertyName_)
                             , std::move(propertySignature_)
                             , std::move(getter_)
-                            , std::move(setter_) );
+                            , 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_) );
 }
 
 

src/Flags.cpp

@@ -0,0 +1,111 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Flags.cpp
+ *
+ * Created on: Dec 31, 2018
+ * 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++/Flags.h>
+#include <systemd/sd-bus.h>
+
+namespace sdbus
+{
+    uint64_t Flags::toSdBusInterfaceFlags() const
+    {
+        uint64_t sdbusFlags{};
+
+        using namespace sdbus;
+        if (flags_.test(Flags::DEPRECATED))
+            sdbusFlags |= SD_BUS_VTABLE_DEPRECATED;
+        if (!flags_.test(Flags::PRIVILEGED))
+            sdbusFlags |= SD_BUS_VTABLE_UNPRIVILEGED;
+
+        if (flags_.test(Flags::EMITS_CHANGE_SIGNAL))
+            sdbusFlags |= SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE;
+        else if (flags_.test(Flags::EMITS_INVALIDATION_SIGNAL))
+            sdbusFlags |= SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION;
+        else if (flags_.test(Flags::CONST_PROPERTY_VALUE))
+            sdbusFlags |= SD_BUS_VTABLE_PROPERTY_CONST;
+        else if (flags_.test(Flags::EMITS_NO_SIGNAL))
+            sdbusFlags |= 0;
+        
+        return sdbusFlags;
+    }
+
+    uint64_t Flags::toSdBusMethodFlags() const
+    {
+        uint64_t sdbusFlags{};
+
+        using namespace sdbus;
+        if (flags_.test(Flags::DEPRECATED))
+            sdbusFlags |= SD_BUS_VTABLE_DEPRECATED;
+        if (!flags_.test(Flags::PRIVILEGED))
+            sdbusFlags |= SD_BUS_VTABLE_UNPRIVILEGED;
+        if (flags_.test(Flags::METHOD_NO_REPLY))
+            sdbusFlags |= SD_BUS_VTABLE_METHOD_NO_REPLY;
+
+        return sdbusFlags;
+    }
+
+    uint64_t Flags::toSdBusSignalFlags() const
+    {
+        uint64_t sdbusFlags{};
+
+        using namespace sdbus;
+        if (flags_.test(Flags::DEPRECATED))
+            sdbusFlags |= SD_BUS_VTABLE_DEPRECATED;
+
+        return sdbusFlags;
+    }
+
+    uint64_t Flags::toSdBusPropertyFlags() const
+    {
+        uint64_t sdbusFlags{};
+
+        using namespace sdbus;
+        if (flags_.test(Flags::DEPRECATED))
+            sdbusFlags |= SD_BUS_VTABLE_DEPRECATED;
+        //if (!flags_.test(Flags::PRIVILEGED))
+        //    sdbusFlags |= SD_BUS_VTABLE_UNPRIVILEGED;
+
+        if (flags_.test(Flags::EMITS_CHANGE_SIGNAL))
+            sdbusFlags |= SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE;
+        else if (flags_.test(Flags::EMITS_INVALIDATION_SIGNAL))
+            sdbusFlags |= SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION;
+        else if (flags_.test(Flags::CONST_PROPERTY_VALUE))
+            sdbusFlags |= SD_BUS_VTABLE_PROPERTY_CONST;
+        else if (flags_.test(Flags::EMITS_NO_SIGNAL))
+            sdbusFlags |= 0;
+
+        return sdbusFlags;
+    }
+
+    uint64_t Flags::toSdBusWritablePropertyFlags() const
+    {
+        auto sdbusFlags = toSdBusPropertyFlags();
+
+        using namespace sdbus;
+        if (!flags_.test(Flags::PRIVILEGED))
+            sdbusFlags |= SD_BUS_VTABLE_UNPRIVILEGED;
+
+        return sdbusFlags;
+    }
+}

src/IConnection.h

@@ -43,11 +43,11 @@ namespace internal {
     class IConnection
     {
     public:
-        virtual void* addObjectVTable( const std::string& objectPath
-                                     , const std::string& interfaceName
-                                     , const void* vtable
-                                     , void* userData ) = 0;
-        virtual void removeObjectVTable(void* vtableHandle) = 0;
+        virtual sd_bus_slot* addObjectVTable( const std::string& objectPath
+                                            , const std::string& interfaceName
+                                            , const sd_bus_vtable* vtable
+                                            , void* userData ) = 0;
+        virtual void removeObjectVTable(sd_bus_slot* vtableHandle) = 0;
 
         virtual sdbus::MethodCall createMethodCall( const std::string& destination
                                                   , const std::string& objectPath
@@ -58,12 +58,12 @@ namespace internal {
                                           , const std::string& interfaceName
                                           , const std::string& signalName ) const = 0;
 
-        virtual void* registerSignalHandler( const std::string& objectPath
-                                           , const std::string& interfaceName
-                                           , const std::string& signalName
-                                           , sd_bus_message_handler_t callback
-                                           , void* userData ) = 0;
-        virtual void unregisterSignalHandler(void* handlerCookie) = 0;
+        virtual sd_bus_slot* registerSignalHandler( const std::string& objectPath
+                                                  , const std::string& interfaceName
+                                                  , const std::string& signalName
+                                                  , sd_bus_message_handler_t callback
+                                                  , void* userData ) = 0;
+        virtual void unregisterSignalHandler(sd_bus_slot* handlerCookie) = 0;
 
         virtual void enterProcessingLoopAsync() = 0;
         virtual void leaveProcessingLoop() = 0;

src/ISdBus.h

@@ -0,0 +1,59 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file ISdBus.h
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Mar 12, 2019
+ * 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/>.
+ */
+
+#ifndef SDBUS_CXX_ISDBUS_H
+#define SDBUS_CXX_ISDBUS_H
+
+#include <systemd/sd-bus.h>
+
+namespace sdbus { namespace internal {
+
+    class ISdBus
+    {
+    public:
+        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_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 sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) = 0;
+        virtual int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member) = 0;
+        virtual sd_bus_message* sd_bus_message_unref(sd_bus_message *m) = 0;
+        virtual int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member) = 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;
+        virtual int sd_bus_open_user(sd_bus **ret) = 0;
+        virtual int sd_bus_open_system(sd_bus **ret) = 0;
+        virtual int sd_bus_flush(sd_bus *bus) = 0;
+        virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) = 0;
+        virtual int sd_bus_get_fd(sd_bus *bus) = 0;
+        virtual int sd_bus_get_events(sd_bus *bus) = 0;
+        virtual int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) = 0;
+        virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) = 0;
+
+        virtual ~ISdBus() = default;
+    };
+
+}}
+
+#endif //SDBUS_CXX_ISDBUS_H

src/Message.cpp

@@ -571,7 +571,28 @@ void* Message::getMsg() const
     return msg_;
 }
 
+void MethodCall::dontExpectReply()
+{
+    auto r = sd_bus_message_set_expect_reply((sd_bus_message*)getMsg(), 0);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set the dont-expect-reply flag", -r);
+}
+
+bool MethodCall::doesntExpectReply() const
+{
+    auto r = sd_bus_message_get_expect_reply((sd_bus_message*)getMsg());
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get the dont-expect-reply flag", -r);
+    return r > 0 ? false : true;
+}
+
 MethodReply MethodCall::send() const
+{
+    if (!doesntExpectReply())
+        return sendWithReply();
+    else
+        return sendWithNoReply();
+}
+
+MethodReply MethodCall::sendWithReply() const
 {
     sd_bus_message* sdbusReply{};
     SCOPE_EXIT{ sd_bus_message_unref(sdbusReply); }; // Returned message will become an owner of sdbusReply
@@ -590,6 +611,13 @@ MethodReply MethodCall::send() const
     return MethodReply(sdbusReply);
 }
 
+MethodReply MethodCall::sendWithNoReply() const
+{
+    auto r = sd_bus_send(nullptr, (sd_bus_message*)getMsg(), nullptr);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method with no reply", -r);
+    return MethodReply{}; // No reply
+}
+
 MethodReply MethodCall::createReply() const
 {
     sd_bus_message *sdbusReply{};

src/Object.cpp

@@ -28,6 +28,7 @@
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/Error.h>
 #include <sdbus-c++/MethodResult.h>
+#include <sdbus-c++/Flags.h>
 #include "IConnection.h"
 #include "VTableUtils.h"
 #include <systemd/sd-bus.h>
@@ -45,7 +46,8 @@ void Object::registerMethod( const std::string& interfaceName
                            , const std::string& methodName
                            , const std::string& inputSignature
                            , const std::string& outputSignature
-                           , method_callback methodCallback )
+                           , method_callback methodCallback
+                           , Flags flags )
 {
     SDBUS_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);
 
@@ -57,7 +59,7 @@ void Object::registerMethod( const std::string& interfaceName
     };
 
     auto& interface = interfaces_[interfaceName];
-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(syncCallback)};
+    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(syncCallback), flags};
     auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
@@ -67,7 +69,8 @@ void Object::registerMethod( const std::string& interfaceName
                            , const std::string& methodName
                            , const std::string& inputSignature
                            , const std::string& outputSignature
-                           , async_method_callback asyncMethodCallback )
+                           , async_method_callback asyncMethodCallback
+                           , Flags flags )
 {
     SDBUS_THROW_ERROR_IF(!asyncMethodCallback, "Invalid method callback provided", EINVAL);
 
@@ -78,7 +81,7 @@ void Object::registerMethod( const std::string& interfaceName
     };
 
     auto& interface = interfaces_[interfaceName];
-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(asyncCallback)};
+    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(asyncCallback), flags};
     auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
@@ -86,11 +89,12 @@ void Object::registerMethod( const std::string& interfaceName
 
 void Object::registerSignal( const std::string& interfaceName
                            , const std::string& signalName
-                           , const std::string& signature )
+                           , const std::string& signature
+                           , Flags flags )
 {
     auto& interface = interfaces_[interfaceName];
 
-    InterfaceData::SignalData signalData{signature};
+    InterfaceData::SignalData signalData{signature, flags};
     auto inserted = interface.signals_.emplace(signalName, std::move(signalData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register signal: signal already exists", EINVAL);
@@ -99,31 +103,40 @@ void Object::registerSignal( const std::string& interfaceName
 void Object::registerProperty( const std::string& interfaceName
                              , const std::string& propertyName
                              , const std::string& signature
-                             , property_get_callback getCallback )
+                             , property_get_callback getCallback
+                             , Flags flags )
 {
     registerProperty( interfaceName
                     , propertyName
                     , signature
                     , getCallback
-                    , property_set_callback{} );
+                    , property_set_callback{}
+                    , flags );
 }
 
 void Object::registerProperty( const std::string& interfaceName
                              , const std::string& propertyName
                              , const std::string& signature
                              , property_get_callback getCallback
-                             , property_set_callback setCallback )
+                             , property_set_callback setCallback
+                             , Flags flags )
 {
     SDBUS_THROW_ERROR_IF(!getCallback && !setCallback, "Invalid property callbacks provided", EINVAL);
 
     auto& interface = interfaces_[interfaceName];
 
-    InterfaceData::PropertyData propertyData{signature, std::move(getCallback), std::move(setCallback)};
+    InterfaceData::PropertyData propertyData{signature, std::move(getCallback), std::move(setCallback), flags};
     auto inserted = interface.properties_.emplace(propertyName, std::move(propertyData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register property: property already exists", EINVAL);
 }
 
+void Object::setInterfaceFlags(const std::string& interfaceName, Flags flags)
+{
+    auto& interface = interfaces_[interfaceName];
+    interface.flags_ = flags;
+}
+
 void Object::finishRegistration()
 {
     for (auto& item : interfaces_)
@@ -159,7 +172,7 @@ const std::vector<sd_bus_vtable>& Object::createInterfaceVTable(InterfaceData& i
     auto& vtable = interfaceData.vtable_;
     assert(vtable.empty());
 
-    vtable.push_back(createVTableStartItem());
+    vtable.push_back(createVTableStartItem(interfaceData.flags_.toSdBusInterfaceFlags()));
     registerMethodsToVTable(interfaceData, vtable);
     registerSignalsToVTable(interfaceData, vtable);
     registerPropertiesToVTable(interfaceData, vtable);
@@ -178,7 +191,8 @@ void Object::registerMethodsToVTable(const InterfaceData& interfaceData, std::ve
         vtable.push_back(createVTableMethodItem( methodName.c_str()
                                                , methodData.inputArgs_.c_str()
                                                , methodData.outputArgs_.c_str()
-                                               , &Object::sdbus_method_callback ));
+                                               , &Object::sdbus_method_callback
+                                               , methodData.flags_.toSdBusMethodFlags() ));
     }
 }
 
@@ -190,7 +204,8 @@ void Object::registerSignalsToVTable(const InterfaceData& interfaceData, std::ve
         const auto& signalData = item.second;
 
         vtable.push_back(createVTableSignalItem( signalName.c_str()
-                                               , signalData.signature_.c_str() ));
+                                               , signalData.signature_.c_str()
+                                               , signalData.flags_.toSdBusSignalFlags() ));
     }
 }
 
@@ -204,12 +219,14 @@ void Object::registerPropertiesToVTable(const InterfaceData& interfaceData, std:
         if (!propertyData.setCallback_)
             vtable.push_back(createVTablePropertyItem( propertyName.c_str()
                                                      , propertyData.signature_.c_str()
-                                                     , &Object::sdbus_property_get_callback ));
+                                                     , &Object::sdbus_property_get_callback
+                                                     , propertyData.flags_.toSdBusPropertyFlags() ));
         else
             vtable.push_back(createVTableWritablePropertyItem( propertyName.c_str()
                                                              , propertyData.signature_.c_str()
                                                              , &Object::sdbus_property_get_callback
-                                                             , &Object::sdbus_property_set_callback ));
+                                                             , &Object::sdbus_property_set_callback
+                                                             , propertyData.flags_.toSdBusWritablePropertyFlags() ));
     }
 }
 
@@ -218,9 +235,9 @@ void Object::activateInterfaceVTable( const std::string& interfaceName
                                     , const std::vector<sd_bus_vtable>& vtable )
 {
     // Tell, don't ask
-    auto slot = (sd_bus_slot*) connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
+    auto slot = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
     interfaceData.slot_.reset(slot);
-    interfaceData.slot_.get_deleter() = [this](void *slot){ connection_.removeObjectVTable(slot); };
+    interfaceData.slot_.get_deleter() = [this](sd_bus_slot *slot){ connection_.removeObjectVTable(slot); };
 }
 
 int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)

src/Object.h

@@ -49,28 +49,35 @@ namespace internal {
                            , const std::string& methodName
                            , const std::string& inputSignature
                            , const std::string& outputSignature
-                           , method_callback methodCallback ) override;
+                           , method_callback methodCallback
+                           , Flags flags ) override;
 
         void registerMethod( const std::string& interfaceName
                            , const std::string& methodName
                            , const std::string& inputSignature
                            , const std::string& outputSignature
-                           , async_method_callback asyncMethodCallback ) override;
+                           , async_method_callback asyncMethodCallback
+                           , Flags flags ) override;
 
         void registerSignal( const std::string& interfaceName
                            , const std::string& signalName
-                           , const std::string& signature ) override;
-
-        void registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
-                             , property_get_callback getCallback ) override;
+                           , const std::string& signature
+                           , Flags flags ) override;
 
         void registerProperty( const std::string& interfaceName
                              , const std::string& propertyName
                              , const std::string& signature
                              , property_get_callback getCallback
-                             , property_set_callback setCallback ) override;
+                             , Flags flags ) override;
+
+        void registerProperty( const std::string& interfaceName
+                             , const std::string& propertyName
+                             , const std::string& signature
+                             , property_get_callback getCallback
+                             , property_set_callback setCallback
+                             , Flags flags ) override;
+
+        void setInterfaceFlags(const std::string& interfaceName, Flags flags) override;
 
         void finishRegistration() override;
 
@@ -89,12 +96,14 @@ namespace internal {
                 std::string inputArgs_;
                 std::string outputArgs_;
                 std::function<void(MethodCall&)> callback_;
+                Flags flags_;
             };
             std::map<MethodName, MethodData> methods_;
             using SignalName = std::string;
             struct SignalData
             {
                 std::string signature_;
+                Flags flags_;
             };
             std::map<SignalName, SignalData> signals_;
             using PropertyName = std::string;
@@ -103,11 +112,13 @@ namespace internal {
                 std::string signature_;
                 property_get_callback getCallback_;
                 property_set_callback setCallback_;
+                Flags flags_;
             };
             std::map<PropertyName, PropertyData> properties_;
             std::vector<sd_bus_vtable> vtable_;
+            Flags flags_;
 
-            std::unique_ptr<void, std::function<void(void*)>> slot_;
+            std::unique_ptr<sd_bus_slot, std::function<void(sd_bus_slot*)>> slot_;
         };
 
         static const std::vector<sd_bus_vtable>& createInterfaceVTable(InterfaceData& interfaceData);

src/ObjectProxy.cpp

@@ -131,7 +131,7 @@ void ObjectProxy::registerSignalHandlers(sdbus::internal::IConnection& connectio
                                                                , &ObjectProxy::sdbus_signal_callback
                                                                , this );
             slot.reset(rawSlotPtr);
-            slot.get_deleter() = [&connection](void *slot){ connection.unregisterSignalHandler(slot); };
+            slot.get_deleter() = [&connection](sd_bus_slot *slot){ connection.unregisterSignalHandler(slot); };
         }
     }
 }

src/ObjectProxy.h

@@ -50,7 +50,7 @@ namespace internal {
         ObjectProxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
                    , std::string destination
                    , std::string objectPath );
-        ~ObjectProxy();
+        ~ObjectProxy() override;
 
         MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) override;
         MethodReply callMethod(const MethodCall& message) override;
@@ -81,7 +81,7 @@ namespace internal {
             struct SignalData
             {
                 signal_handler callback_;
-                std::unique_ptr<void, std::function<void(void*)>> slot_;
+                std::unique_ptr<sd_bus_slot, std::function<void(sd_bus_slot*)>> slot_;
             };
             std::map<SignalName, SignalData> signals_;
         };

src/SdBus.cpp

@@ -0,0 +1,111 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file SdBus.cpp
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Mar 3, 2019
+ * 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.h"
+
+namespace sdbus { namespace internal {
+
+int SdBus::sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags)
+{
+    return ::sd_bus_request_name(bus, name, flags);
+}
+
+int SdBus::sd_bus_release_name(sd_bus *bus, const char *name)
+{
+    return ::sd_bus_release_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)
+{
+    return ::sd_bus_add_object_vtable(bus, slot, path, interface,  vtable, userdata);
+}
+
+sd_bus_slot* SdBus::sd_bus_slot_unref(sd_bus_slot *slot)
+{
+    return ::sd_bus_slot_unref(slot);
+}
+
+int SdBus::sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member)
+{
+    return ::sd_bus_message_new_method_call(bus, m, destination, path, interface, member);
+}
+
+sd_bus_message* SdBus::sd_bus_message_unref(sd_bus_message *m)
+{
+    return ::sd_bus_message_unref(m);
+}
+
+int SdBus::sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member)
+{
+    return ::sd_bus_message_new_signal(bus, m, path, interface, member);
+}
+
+int SdBus::sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata)
+{
+    return :: sd_bus_add_match(bus, slot, match, callback, userdata);
+}
+
+int SdBus::sd_bus_open_user(sd_bus **ret)
+{
+    return ::sd_bus_open_user(ret);
+}
+
+int SdBus::sd_bus_open_system(sd_bus **ret)
+{
+    return ::sd_bus_open_system(ret);
+}
+
+int SdBus::sd_bus_flush(sd_bus *bus)
+{
+    return ::sd_bus_flush(bus);
+}
+
+int SdBus::sd_bus_process(sd_bus *bus, sd_bus_message **r)
+{
+    return ::sd_bus_process(bus, r);
+}
+
+int SdBus::sd_bus_get_fd(sd_bus *bus)
+{
+    return ::sd_bus_get_fd(bus);
+}
+
+int SdBus::sd_bus_get_events(sd_bus *bus)
+{
+    return ::sd_bus_get_events(bus);
+}
+
+int SdBus::sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec)
+{
+    return ::sd_bus_get_timeout(bus, timeout_usec);
+}
+
+sd_bus* SdBus::sd_bus_flush_close_unref(sd_bus *bus)
+{
+    return ::sd_bus_flush_close_unref(bus);
+}
+
+}}

src/SdBus.h

@@ -0,0 +1,57 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file SdBus.h
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Mar 3, 2019
+ * 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/>.
+ */
+
+#ifndef SDBUS_CXX_SDBUS_H
+#define SDBUS_CXX_SDBUS_H
+
+#include "ISdBus.h"
+
+namespace sdbus { namespace internal {
+
+class SdBus : public ISdBus
+{
+public:
+    int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) override;
+    int sd_bus_release_name(sd_bus *bus, const char *name) override;
+    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;
+    sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) override;
+    int sd_bus_message_new_method_call(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member) override;
+    sd_bus_message* sd_bus_message_unref(sd_bus_message *m) override;
+    int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member) override;
+    int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) override;
+    int sd_bus_open_user(sd_bus **ret) override;
+    int sd_bus_open_system(sd_bus **ret) override;
+    int sd_bus_flush(sd_bus *bus) override;
+    int sd_bus_process(sd_bus *bus, sd_bus_message **r) override;
+    int sd_bus_get_fd(sd_bus *bus) override;
+    int sd_bus_get_events(sd_bus *bus) override;
+    int sd_bus_get_timeout(sd_bus *bus, uint64_t *timeout_usec) override;
+    sd_bus *sd_bus_flush_close_unref(sd_bus *bus) override;
+};
+
+}}
+
+#endif //SDBUS_C_SDBUS_H

src/VTableUtils.c

@@ -26,42 +26,46 @@
 #include "VTableUtils.h"
 #include <systemd/sd-bus.h>
 
-sd_bus_vtable createVTableStartItem()
+sd_bus_vtable createVTableStartItem(uint64_t flags)
 {
-    struct sd_bus_vtable vtableStart = SD_BUS_VTABLE_START(0);
+    struct sd_bus_vtable vtableStart = SD_BUS_VTABLE_START(flags);
     return vtableStart;
 }
 
 sd_bus_vtable createVTableMethodItem( const char *member
                                     , const char *signature
                                     , const char *result
-                                    , sd_bus_message_handler_t handler )
+                                    , sd_bus_message_handler_t handler
+                                    , uint64_t flags )
 {
-    struct sd_bus_vtable vtableItem = SD_BUS_METHOD(member, signature, result, handler, SD_BUS_VTABLE_UNPRIVILEGED);
+    struct sd_bus_vtable vtableItem = SD_BUS_METHOD(member, signature, result, handler, flags);
     return vtableItem;
 }
 
 sd_bus_vtable createVTableSignalItem( const char *member
-                                    , const char *signature )
+                                    , const char *signature
+                                    , uint64_t flags )
 {
-    struct sd_bus_vtable vtableItem = SD_BUS_SIGNAL(member, signature, 0);
+    struct sd_bus_vtable vtableItem = SD_BUS_SIGNAL(member, signature, flags);
     return vtableItem;
 }
 
 sd_bus_vtable createVTablePropertyItem( const char *member
                                       , const char *signature
-                                      , sd_bus_property_get_t getter )
+                                      , sd_bus_property_get_t getter
+                                      , uint64_t flags )
 {
-    struct sd_bus_vtable vtableItem = SD_BUS_PROPERTY(member, signature, getter, 0, 0);
+    struct sd_bus_vtable vtableItem = SD_BUS_PROPERTY(member, signature, getter, 0, flags);
     return vtableItem;
 }
 
 sd_bus_vtable createVTableWritablePropertyItem( const char *member
                                               , const char *signature
                                               , sd_bus_property_get_t getter
-                                              , sd_bus_property_set_t setter )
+                                              , sd_bus_property_set_t setter
+                                              , uint64_t flags )
 {
-    struct sd_bus_vtable vtableItem = SD_BUS_WRITABLE_PROPERTY(member, signature, getter, setter, 0, 0);
+    struct sd_bus_vtable vtableItem = SD_BUS_WRITABLE_PROPERTY(member, signature, getter, setter, 0, flags);
     return vtableItem;
 }
 

src/VTableUtils.h

@@ -27,25 +27,30 @@
 #define SDBUS_CXX_INTERNAL_VTABLEUTILS_H_
 
 #include <systemd/sd-bus.h>
+#include <stdbool.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-sd_bus_vtable createVTableStartItem();
+sd_bus_vtable createVTableStartItem(uint64_t flags);
 sd_bus_vtable createVTableMethodItem( const char *member
                                     , const char *signature
                                     , const char *result
-                                    , sd_bus_message_handler_t handler );
+                                    , sd_bus_message_handler_t handler
+                                    , uint64_t flags );
 sd_bus_vtable createVTableSignalItem( const char *member
-                                    , const char *signature );
+                                    , const char *signature
+                                    , uint64_t flags );
 sd_bus_vtable createVTablePropertyItem( const char *member
                                       , const char *signature
-                                      , sd_bus_property_get_t getter );
+                                      , sd_bus_property_get_t getter
+                                      , uint64_t flags );
 sd_bus_vtable createVTableWritablePropertyItem( const char *member
                                               , const char *signature
                                               , sd_bus_property_get_t getter
-                                              , sd_bus_property_set_t setter );
+                                              , sd_bus_property_set_t setter
+                                              , uint64_t flags );
 sd_bus_vtable createVTableEndItem();
 
 #ifdef __cplusplus

stub-generator/AdaptorGenerator.cpp

@@ -89,6 +89,30 @@ std::string AdaptorGenerator::processInterface(Node& interface) const
     Nodes signals = interface["signal"];
     Nodes properties = interface["property"];
 
+    auto annotations = getAnnotations(interface);
+    std::string annotationRegistration;
+    for (const auto& annotation : annotations)
+    {
+        const auto& annotationName = annotation.first;
+        const auto& annotationValue = annotation.second;
+
+        if (annotationName == "org.freedesktop.DBus.Deprecated" && annotationValue == "true")
+            annotationRegistration += ".markAsDeprecated()";
+        else if (annotationName == "org.freedesktop.systemd1.Privileged" && annotationValue == "true")
+            annotationRegistration += ".markAsPrivileged()";
+        else if (annotationName == "org.freedesktop.DBus.Property.EmitsChangedSignal")
+            annotationRegistration += ".withPropertyUpdateBehavior(" + propertyAnnotationToFlag(annotationValue) + ")";
+        else
+            std::cerr << "Node: " << ifaceName << ": "
+                      << "Option '" << annotationName << "' not allowed or supported in this context! Option ignored..." << std::endl;
+    }
+    if(!annotationRegistration.empty())
+    {
+        std::stringstream str;
+        str << tab << tab << "object_.setInterfaceFlags(interfaceName)" << annotationRegistration << ";" << endl;
+        annotationRegistration = str.str();
+    }
+
     std::string methodRegistration, methodDeclaration;
     std::tie(methodRegistration, methodDeclaration) = processMethods(methods);
 
@@ -99,10 +123,11 @@ std::string AdaptorGenerator::processInterface(Node& interface) const
     std::tie(propertyRegistration, propertyAccessorDeclaration) = processProperties(properties);
 
     body << tab << "{" << endl
-            << methodRegistration
-            << signalRegistration
-            << propertyRegistration
-            << tab << "}" << endl << endl;
+                       << annotationRegistration
+                       << methodRegistration
+                       << signalRegistration
+                       << propertyRegistration
+         << tab << "}" << endl << endl;
 
     if (!signalMethods.empty())
     {
@@ -136,17 +161,25 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
     {
         auto methodName = method->get("name");
 
+        auto annotations = getAnnotations(*method);
         bool async{false};
-        Nodes annotations = (*method)["annotation"];
-
+        std::string annotationRegistration;
         for (const auto& annotation : annotations)
         {
-            if (annotation->get("name") == "org.freedesktop.DBus.Method.Async"
-                && (annotation->get("value") == "server" || annotation->get("value") == "clientserver"))
-            {
+            const auto& annotationName = annotation.first;
+            const auto& annotationValue = annotation.second;
+
+            if (annotationName == "org.freedesktop.DBus.Deprecated" && annotationValue == "true")
+                annotationRegistration += ".markAsDeprecated()";
+            else if (annotationName == "org.freedesktop.DBus.Method.NoReply" && annotationValue == "true")
+                annotationRegistration += ".withNoReply()";
+            else if (annotationName == "org.freedesktop.DBus.Method.Async" && (annotationValue == "server" || annotationValue == "clientserver"))
                 async = true;
-                break;
-            }
+            else if (annotationName == "org.freedesktop.systemd1.Privileged" && annotationValue == "true")
+                annotationRegistration += ".markAsPrivileged()";
+            else
+                std::cerr << "Node: " << methodName << ": "
+                          << "Option '" << annotationName << "' not allowed or supported in this context! Option ignored..." << std::endl;
         }
 
         Nodes args = (*method)["arg"];
@@ -167,7 +200,8 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
                 << argTypeStr
                 << "){ " << (async ? "" : "return ") << "this->" << methodName << "("
                 << (async ? "std::move(result)"s + (argTypeStr.empty() ? "" : ", ") : "")
-                << argStr << "); });" << endl;
+                << argStr << "); })"
+                << annotationRegistration << ";" << endl;
 
         declarationSS << tab
                 << "virtual "
@@ -190,6 +224,21 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
     for (const auto& signal : signals)
     {
         auto name = signal->get("name");
+
+        auto annotations = getAnnotations(*signal);
+        std::string annotationRegistration;
+        for (const auto& annotation : annotations)
+        {
+            const auto& annotationName = annotation.first;
+            const auto& annotationValue = annotation.second;
+
+            if (annotationName == "org.freedesktop.DBus.Deprecated" && annotationValue == "true")
+                annotationRegistration += ".markAsDeprecated()";
+            else
+                std::cerr << "Node: " << name << ": "
+                          << "Option '" << annotationName << "' not allowed or supported in this context! Option ignored..." << std::endl;
+        }
+
         Nodes args = (*signal)["arg"];
 
         std::string argStr, argTypeStr, typeStr;;
@@ -204,6 +253,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
             signalRegistrationSS << ".withParameters<" << typeStr << ">()";
         }
 
+        signalRegistrationSS << annotationRegistration;
         signalRegistrationSS << ";" << endl;
 
         signalMethodSS << tab << "void " << name << "(" << argTypeStr << ")" << endl
@@ -238,6 +288,24 @@ std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const N
         auto propertyArg = std::string("value");
         auto propertyTypeArg = std::string("const ") + propertyType + "& " + propertyArg;
 
+        auto annotations = getAnnotations(*property);
+        std::string annotationRegistration;
+        for (const auto& annotation : annotations)
+        {
+            const auto& annotationName = annotation.first;
+            const auto& annotationValue = annotation.second;
+
+            if (annotationName == "org.freedesktop.DBus.Deprecated" && annotationValue == "true")
+                annotationRegistration += ".markAsDeprecated()";
+            else if (annotationName == "org.freedesktop.DBus.Property.EmitsChangedSignal")
+                annotationRegistration += ".withUpdateBehavior(" + propertyAnnotationToFlag(annotationValue) + ")";
+            else if (annotationName == "org.freedesktop.systemd1.Privileged" && annotationValue == "true")
+                annotationRegistration += ".markAsPrivileged()";
+            else
+                std::cerr << "Node: " << propertyName << ": "
+                          << "Option '" << annotationName << "' not allowed or supported in this context! Option ignored..." << std::endl;
+        }
+
         registrationSS << tab << tab << "object_.registerProperty(\""
                 << propertyName << "\")"
                 << ".onInterface(interfaceName)";
@@ -254,6 +322,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const N
                    "{ this->" << propertyName << "(" << propertyArg << "); })";
         }
 
+        registrationSS << annotationRegistration;
         registrationSS << ";" << endl;
 
         if (propertyAccess == "read" || propertyAccess == "readwrite")
@@ -264,3 +333,25 @@ std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const N
 
     return std::make_tuple(registrationSS.str(), declarationSS.str());
 }
+
+std::map<std::string, std::string> AdaptorGenerator::getAnnotations( sdbuscpp::xml::Node& node) const
+{
+    std::map<std::string, std::string> result;
+
+    Nodes annotations = (node)["annotation"];
+    for (const auto& annotation : annotations)
+    {
+        result[annotation->get("name")] = annotation->get("value");
+    }
+
+    return result;
+}
+
+std::string AdaptorGenerator::propertyAnnotationToFlag(const std::string& annotationValue) const
+{
+    return annotationValue == "true" ? "sdbus::Flags::EMITS_CHANGE_SIGNAL"
+         : annotationValue == "invalidates" ? "sdbus::Flags::EMITS_INVALIDATION_SIGNAL"
+         : annotationValue == "const" ? "sdbus::Flags::CONST_PROPERTY_VALUE"
+         : annotationValue == "false" ? "sdbus::Flags::EMITS_NO_SIGNAL"
+         : "EMITS_CHANGE_SIGNAL"; // Default
+}

stub-generator/AdaptorGenerator.h

@@ -32,6 +32,7 @@
 
 // STL
 #include <tuple>
+#include <set>
 
 class AdaptorGenerator : public BaseGenerator
 {
@@ -73,6 +74,19 @@ private:
      */
     std::tuple<std::string, std::string> processProperties(const sdbuscpp::xml::Nodes& properties) const;
 
+    /**
+     * Get annotations listed for a given node
+     * @param node
+     * @return map of annotation names to their values
+     */
+    std::map<std::string, std::string> getAnnotations(sdbuscpp::xml::Node& node) const;
+
+    /**
+     * Get flag for property update behavior annotation value
+     * @param annotationValue
+     * @return flag
+     */
+    std::string propertyAnnotationToFlag(const std::string& annotationValue) const;
 };
 
 

stub-generator/CMakeLists.txt

@@ -18,13 +18,24 @@ find_package(EXPAT REQUIRED)
 # SOURCE FILES CONFIGURATION
 #-------------------------------
 
-set(SDBUSCPP_XML2CPP_SRCS xml2cpp.cpp xml.cpp generator_utils.cpp BaseGenerator.cpp AdaptorGenerator.cpp ProxyGenerator.cpp)
+set(SDBUSCPP_XML2CPP_SRCS
+    xml2cpp.cpp
+    xml.h
+    xml.cpp
+    generator_utils.h
+    generator_utils.cpp
+    BaseGenerator.h
+    BaseGenerator.cpp
+    AdaptorGenerator.h
+    AdaptorGenerator.cpp
+    ProxyGenerator.h
+    ProxyGenerator.cpp)
 
 #-------------------------------
 # GENERAL COMPILER CONFIGURATION
 #-------------------------------
 
-set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD 14)
 
 #----------------------------------
 # EXECUTABLE BUILD INFORMATION

stub-generator/ProxyGenerator.cpp

@@ -127,6 +127,24 @@ std::string ProxyGenerator::processMethods(const Nodes& methods) const
         Nodes inArgs = args.select("direction" , "in");
         Nodes outArgs = args.select("direction" , "out");
 
+        bool dontExpectReply{false};
+        Nodes annotations = (*method)["annotation"];
+        for (const auto& annotation : annotations)
+        {
+            if (annotation->get("name") == "org.freedesktop.DBus.Method.NoReply"
+                && annotation->get("value") == "true")
+            {
+                dontExpectReply = true;
+                break;
+            }
+        }
+        if (dontExpectReply && outArgs.size() > 0)
+        {
+            std::cerr << "Function: " << name << ": ";
+            std::cerr << "Option 'org.freedesktop.DBus.Method.NoReply' not allowed for methods with 'out' variables! Option ignored..." << std::endl;
+            dontExpectReply = false;
+        }
+
         auto retType = outArgsToType(outArgs);
         std::string argStr, argTypeStr;
         std::tie(argStr, argTypeStr, std::ignore) = argsToNamesAndTypes(inArgs);
@@ -152,6 +170,10 @@ std::string ProxyGenerator::processMethods(const Nodes& methods) const
             methodSS << ".storeResultsTo(result);" << endl
                     << tab << tab << "return result";
         }
+        else if (dontExpectReply)
+        {
+            methodSS << ".dontExpectReply()";
+        }
 
         methodSS << ";" << endl << tab << "}" << endl << endl;
     }
@@ -159,7 +181,6 @@ std::string ProxyGenerator::processMethods(const Nodes& methods) const
     return methodSS.str();
 }
 
-
 std::tuple<std::string, std::string> ProxyGenerator::processSignals(const Nodes& signals) const
 {
     std::ostringstream registrationSS, declarationSS;

test/CMakeLists.txt

@@ -36,7 +36,9 @@ set(UNITTESTS_SRCS
     ${UNITTESTS_SOURCE_DIR}/libsdbus-c++_unittests.cpp
     ${UNITTESTS_SOURCE_DIR}/Message_test.cpp
     ${UNITTESTS_SOURCE_DIR}/Types_test.cpp
-    ${UNITTESTS_SOURCE_DIR}/TypeTraits_test.cpp)
+    ${UNITTESTS_SOURCE_DIR}/TypeTraits_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/Connection_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/mocks/SdBusMock.h)
 
 set(INTEGRATIONTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/integrationtests)
 set(INTEGRATIONTESTS_SRCS
@@ -69,6 +71,15 @@ target_link_libraries(libsdbus-c++_unittests ${SYSTEMD_LIBRARIES} gmock gmock_ma
 add_executable(libsdbus-c++_integrationtests ${INTEGRATIONTESTS_SRCS})
 target_link_libraries(libsdbus-c++_integrationtests sdbus-c++ gmock gmock_main)
 
+# Manual performance tests
+option(ENABLE_PERFTESTS "Build and install manual performance tests (default OFF)" OFF)
+if(ENABLE_PERFTESTS)
+    add_executable(libsdbus-c++_perftests_client perftests/client.cpp perftests/perftest-proxy.h)
+    target_link_libraries(libsdbus-c++_perftests_client sdbus-c++)
+    add_executable(libsdbus-c++_perftests_server perftests/server.cpp perftests/perftest-adaptor.h)
+    target_link_libraries(libsdbus-c++_perftests_server sdbus-c++)
+endif()
+
 #----------------------------------
 # INSTALLATION
 #----------------------------------
@@ -77,6 +88,12 @@ install(TARGETS libsdbus-c++_unittests DESTINATION /opt/test/bin)
 install(TARGETS libsdbus-c++_integrationtests DESTINATION /opt/test/bin)
 install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/libsdbus-cpp-test.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
 
+if(ENABLE_PERFTESTS)
+    install(TARGETS libsdbus-c++_perftests_client DESTINATION /opt/test/bin)
+    install(TARGETS libsdbus-c++_perftests_server DESTINATION /opt/test/bin)
+    install(FILES perftests/files/org.sdbuscpp.perftest.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
+endif()
+
 #----------------------------------
 # RUNNING THE TESTS UPON BUILD
 #----------------------------------

test/integrationtests/AdaptorAndProxy_test.cpp

@@ -25,6 +25,7 @@
 
 // Own
 #include "Connection.h"
+#include "SdBus.h"
 
 #include "TestingAdaptor.h"
 #include "TestingProxy.h"
@@ -41,6 +42,7 @@
 #include <thread>
 #include <tuple>
 #include <chrono>
+#include <fstream>
 
 using ::testing::Eq;
 using ::testing::Gt;
@@ -55,20 +57,20 @@ class AdaptorAndProxyFixture : public ::testing::Test
 public:
     static void SetUpTestCase()
     {
-        m_connection.requestName(INTERFACE_NAME);
-        m_connection.enterProcessingLoopAsync();
+        s_connection->requestName(INTERFACE_NAME);
+        s_connection->enterProcessingLoopAsync();
     }
 
     static void TearDownTestCase()
     {
-        m_connection.leaveProcessingLoop();
-        m_connection.releaseName(INTERFACE_NAME);
+        s_connection->leaveProcessingLoop();
+        s_connection->releaseName(INTERFACE_NAME);
     }
 
 private:
     void SetUp() override
     {
-        m_adaptor = std::make_unique<TestingAdaptor>(m_connection);
+        m_adaptor = std::make_unique<TestingAdaptor>(*s_connection);
         m_proxy = std::make_unique<TestingProxy>(INTERFACE_NAME, OBJECT_PATH);
         std::this_thread::sleep_for(50ms); // Give time for the proxy to start listening to signals
     }
@@ -80,13 +82,13 @@ private:
     }
 
 public:
-    static sdbus::internal::Connection m_connection;
+    static std::unique_ptr<sdbus::IConnection> s_connection;
 
     std::unique_ptr<TestingAdaptor> m_adaptor;
     std::unique_ptr<TestingProxy> m_proxy;
 };
 
-sdbus::internal::Connection AdaptorAndProxyFixture::m_connection{sdbus::internal::Connection::BusType::eSystem};
+std::unique_ptr<sdbus::IConnection> AdaptorAndProxyFixture::s_connection = sdbus::createSystemBusConnection();
 
 }
 
@@ -200,6 +202,51 @@ TEST_F(SdbusTestObject, CallsMethodWithComplexTypeSuccesfully)
     ASSERT_THAT(resComplex.count(0), Eq(1));
 }
 
+TEST_F(SdbusTestObject, CallsMultiplyMethodWithNoReplyFlag)
+{
+    m_proxy->multiplyWithNoReply(INT64_VALUE, DOUBLE_VALUE);
+
+    for (auto i = 0; i < 100; ++i)
+    {
+        if (m_adaptor->wasMultiplyCalled())
+            break;
+        std::this_thread::sleep_for(10ms);
+    }
+    ASSERT_TRUE(m_adaptor->wasMultiplyCalled());
+    ASSERT_THAT(m_adaptor->getMultiplyResult(), Eq(INT64_VALUE * DOUBLE_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodThatThrowsError)
+{
+    try
+    {
+        m_proxy->throwError();
+        FAIL() << "Expected sdbus::Error exception";
+    }
+    catch (const sdbus::Error& e)
+    {
+        ASSERT_THAT(e.getName(), Eq("org.freedesktop.DBus.Error.AccessDenied"));
+        ASSERT_THAT(e.getMessage(), Eq("A test error occurred (Operation not permitted)"));
+    }
+    catch(...)
+    {
+        FAIL() << "Expected sdbus::Error exception";
+    }
+}
+
+TEST_F(SdbusTestObject, CallsErrorThrowingMethodWithDontExpectReplySet)
+{
+    ASSERT_NO_THROW(m_proxy->throwErrorWithNoReply());
+
+    for (auto i = 0; i < 100; ++i)
+    {
+        if (m_adaptor->wasThrowErrorCalled())
+            break;
+        std::this_thread::sleep_for(10ms);
+    }
+    ASSERT_TRUE(m_adaptor->wasThrowErrorCalled());
+}
+
 TEST_F(SdbusTestObject, DoesServerSideAsynchoronousMethodInParallel)
 {
     // Yeah, this is kinda timing-dependent test, but times should be safe...
@@ -227,7 +274,6 @@ TEST_F(SdbusTestObject, DoesServerSideAsynchoronousMethodInParallel)
 
 TEST_F(SdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
 {
-    std::mutex mtx;
     std::atomic<size_t> resultCount{};
     std::atomic<bool> invoke{};
     std::atomic<int> startedCount{};
@@ -268,13 +314,13 @@ TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentInterface)
 
 TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentDestination)
 {
-    TestingProxy proxy("wrongDestination", OBJECT_PATH);
+    TestingProxy proxy("sdbuscpp.destination.that.does.not.exist", OBJECT_PATH);
     ASSERT_THROW(proxy.getInt(), sdbus::Error);
 }
 
 TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentObject)
 {
-    TestingProxy proxy(INTERFACE_NAME, "/wrong/path");
+    TestingProxy proxy(INTERFACE_NAME, "/sdbuscpp/path/that/does/not/exist");
     ASSERT_THROW(proxy.getInt(), sdbus::Error);
 }
 
@@ -317,11 +363,6 @@ TEST_F(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
     ASSERT_THAT(signature["platform"], Eq("av"));
 }
 
-TEST_F(SdbusTestObject, failsEmitingSignalOnNonexistentInterface)
-{
-    ASSERT_THROW(m_adaptor->emitSignalOnNonexistentInterface(), sdbus::Error);
-}
-
 // Properties
 
 TEST_F(SdbusTestObject, ReadsReadPropertySuccesfully)
@@ -331,7 +372,7 @@ TEST_F(SdbusTestObject, ReadsReadPropertySuccesfully)
 
 TEST_F(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
 {
-    auto x = 42;
+    uint32_t x = 42;
     ASSERT_NO_THROW(m_proxy->action(x));
     ASSERT_THAT(m_proxy->action(), Eq(x));
 }
@@ -346,3 +387,8 @@ TEST_F(SdbusTestObject, CannotReadFromWriteProperty)
 {
     ASSERT_THROW(m_proxy->blocking(), sdbus::Error);
 }
+
+TEST_F(SdbusTestObject, AnswersXmlApiDescriptionOnIntrospection)
+{
+    ASSERT_THAT(m_proxy->Introspect(), Eq(m_adaptor->getExpectedXmlApiDescription()));
+}

test/integrationtests/Connection_test.cpp

@@ -60,7 +60,7 @@ TEST(Connection, CanRequestRegisteredDbusName)
 TEST(Connection, CannotRequestNonregisteredDbusName)
 {
     auto connection = sdbus::createConnection();
-    ASSERT_THROW(connection->requestName("some_random_not_supported_dbus_name"), sdbus::Error);
+    ASSERT_THROW(connection->requestName("some.random.not.supported.dbus.name"), sdbus::Error);
 }
 
 TEST(Connection, CanReleasedRequestedName)
@@ -74,7 +74,7 @@ TEST(Connection, CanReleasedRequestedName)
 TEST(Connection, CannotReleaseNonrequestedName)
 {
     auto connection = sdbus::createConnection();
-    ASSERT_THROW(connection->releaseName("some_random_nonrequested_name"), sdbus::Error);
+    ASSERT_THROW(connection->releaseName("some.random.nonrequested.name"), sdbus::Error);
 }
 
 TEST(Connection, CanEnterAndLeaveProcessingLoop)

test/integrationtests/TestingAdaptor.h

@@ -29,6 +29,7 @@
 #include "adaptor-glue.h"
 #include <thread>
 #include <chrono>
+#include <atomic>
 
 class TestingAdaptor : public sdbus::Interfaces<testing_adaptor>
 {
@@ -38,6 +39,10 @@ public:
 
     virtual ~TestingAdaptor() { }
 
+    bool wasMultiplyCalled() const { return m_multiplyCalled; }
+    double getMultiplyResult() const { return m_multiplyResult; }
+    bool wasThrowErrorCalled() const { return m_throwErrorCalled; }
+
 protected:
 
     void noArgNoReturn() const { }
@@ -48,6 +53,12 @@ protected:
 
     double multiply(const int64_t& a, const double& b) const { return a * b; }
 
+    void multiplyWithNoReply(const int64_t& a, const double& b) const
+    {
+        m_multiplyResult = a * b;
+        m_multiplyCalled = true;
+    }
+
     std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x) const
     {
         std::vector<int16_t> res{x.get<1>()};
@@ -154,6 +165,12 @@ protected:
         };
     }
 
+    void throwError() const
+    {
+        m_throwErrorCalled = true;
+        throw sdbus::createError(1, "A test error occurred");
+    }
+
     std::string state() { return STRING_VALUE; }
     uint32_t action() { return m_action; }
     void action(const uint32_t& value) { m_action = value; }
@@ -164,6 +181,10 @@ private:
     uint32_t m_action;
     bool m_blocking;
 
+    // For dont-expect-reply method call verifications
+    mutable std::atomic<bool> m_multiplyCalled{};
+    mutable double m_multiplyResult{};
+    mutable std::atomic<bool> m_throwErrorCalled{};
 };
 
 

test/integrationtests/TestingProxy.h

@@ -28,10 +28,10 @@
 
 #include "proxy-glue.h"
 
-class TestingProxy : public sdbus::ProxyInterfaces<::testing_proxy>
+class TestingProxy : public sdbus::ProxyInterfaces<::testing_proxy, sdbus::introspectable_proxy>
 {
 public:
-    using sdbus::ProxyInterfaces<::testing_proxy>::ProxyInterfaces;
+    using sdbus::ProxyInterfaces<::testing_proxy, sdbus::introspectable_proxy>::ProxyInterfaces;
 
     int getSimpleCallCount() const { return m_simpleCallCounter; }
     std::map<int32_t, std::string> getMap() const { return m_map; }

test/integrationtests/adaptor-glue.h

@@ -57,11 +57,14 @@ protected:
     testing_adaptor(sdbus::IObject& object) :
         object_(object)
     {
+        object_.setInterfaceFlags(INTERFACE_NAME).markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
+
         object_.registerMethod("noArgNoReturn").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->noArgNoReturn(); });
         object_.registerMethod("getInt").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getInt(); });
         object_.registerMethod("getTuple").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getTuple(); });
 
         object_.registerMethod("multiply").onInterface(INTERFACE_NAME).implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); });
+        object_.registerMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).implementedAs([this](const int64_t& a, const double& b){ this->multiplyWithNoReply(a, b); }).markAsDeprecated().withNoReply();
         object_.registerMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).implementedAs([this](
                 const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x){ return this->getInts16FromStruct(x); });
 
@@ -95,15 +98,20 @@ protected:
         object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getSignature(); });
         object_.registerMethod("getObjectPath").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getObjectPath(); });
 
-        object_.registerMethod("getComplex").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getComplex(); });
+        object_.registerMethod("getComplex").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getComplex(); }).markAsDeprecated();
+
+        object_.registerMethod("throwError").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->throwError(); });
+        object_.registerMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).implementedAs([this](){ this->throwError(); }).withNoReply();
+
+        object_.registerMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME).implementedAs([](){}).markAsPrivileged();
 
         // registration of signals is optional, it is useful because of introspection
-        object_.registerSignal("simpleSignal").onInterface(INTERFACE_NAME);
+        object_.registerSignal("simpleSignal").onInterface(INTERFACE_NAME).markAsDeprecated();
         object_.registerSignal("signalWithMap").onInterface(INTERFACE_NAME).withParameters<std::map<int32_t, std::string>>();
         object_.registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>();
 
-        object_.registerProperty("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); });
-        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); });
+        object_.registerProperty("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE);
+        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
         object_.registerProperty("blocking").onInterface(INTERFACE_NAME)./*withGetter([this](){ return this->blocking(); }).*/withSetter([this](const bool& value){ this->blocking(value); });
 
     }
@@ -131,7 +139,7 @@ public:
 
     void emitSignalOnNonexistentInterface()
     {
-        object_.emitSignal("simpleSignal").onInterface("interfaceThatDoesNotExists");
+        object_.emitSignal("simpleSignal").onInterface("sdbuscpp.interface.that.does.not.exist");
     }
 
 private:
@@ -143,6 +151,7 @@ protected:
     virtual int32_t getInt() const = 0;
     virtual std::tuple<uint32_t, std::string> getTuple() const = 0;
     virtual double multiply(const int64_t& a, const double& b) const = 0;
+    virtual void multiplyWithNoReply(const int64_t& a, const double& b) const = 0;
     virtual std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x) const = 0;
     virtual sdbus::Variant processVariant(sdbus::Variant& v) = 0;
     virtual std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) const = 0;
@@ -154,6 +163,7 @@ protected:
     virtual sdbus::Signature getSignature() const  = 0;
     virtual sdbus::ObjectPath getObjectPath() const = 0;
     virtual ComplexType getComplex() const = 0;
+    virtual void throwError() const = 0;
 
     virtual std::string state() = 0;
     virtual uint32_t action() = 0;
@@ -161,6 +171,142 @@ protected:
     virtual bool blocking() = 0;
     virtual void blocking(const bool& value) = 0;
 
+public: // For testing purposes
+    std::string getExpectedXmlApiDescription()
+    {
+        return
+R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN"
+"http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
+<node>
+ <interface name="org.freedesktop.DBus.Peer">
+  <method name="Ping"/>
+  <method name="GetMachineId">
+   <arg type="s" name="machine_uuid" direction="out"/>
+  </method>
+ </interface>
+ <interface name="org.freedesktop.DBus.Introspectable">
+  <method name="Introspect">
+   <arg name="data" type="s" direction="out"/>
+  </method>
+ </interface>
+ <interface name="org.freedesktop.DBus.Properties">
+  <method name="Get">
+   <arg name="interface" direction="in" type="s"/>
+   <arg name="property" direction="in" type="s"/>
+   <arg name="value" direction="out" type="v"/>
+  </method>
+  <method name="GetAll">
+   <arg name="interface" direction="in" type="s"/>
+   <arg name="properties" direction="out" type="a{sv}"/>
+  </method>
+  <method name="Set">
+   <arg name="interface" direction="in" type="s"/>
+   <arg name="property" direction="in" type="s"/>
+   <arg name="value" direction="in" type="v"/>
+  </method>
+  <signal name="PropertiesChanged">
+   <arg type="s" name="interface"/>
+   <arg type="a{sv}" name="changed_properties"/>
+   <arg type="as" name="invalidated_properties"/>
+  </signal>
+ </interface>
+ <interface name="com.kistler.testsdbuscpp">
+  <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+  <method name="doOperationAsync">
+   <arg type="u" direction="in"/>
+   <arg type="u" direction="out"/>
+  </method>
+  <method name="doOperationSync">
+   <arg type="u" direction="in"/>
+   <arg type="u" direction="out"/>
+  </method>
+  <method name="doPrivilegedStuff">
+   <annotation name="org.freedesktop.systemd1.Privileged" value="true"/>
+  </method>
+  <method name="getComplex">
+   <arg type="a{t(a{ya(obva{is})}gs)}" direction="out"/>
+   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+  </method>
+  <method name="getInt">
+   <arg type="i" direction="out"/>
+  </method>
+  <method name="getInts16FromStruct">
+   <arg type="(yndsan)" direction="in"/>
+   <arg type="an" direction="out"/>
+  </method>
+  <method name="getMapOfVariants">
+   <arg type="ai" direction="in"/>
+   <arg type="(vv)" direction="in"/>
+   <arg type="a{iv}" direction="out"/>
+  </method>
+  <method name="getObjectPath">
+   <arg type="o" direction="out"/>
+  </method>
+  <method name="getSignature">
+   <arg type="g" direction="out"/>
+  </method>
+  <method name="getStructInStruct">
+   <arg type="(s(a{ii}))" direction="out"/>
+  </method>
+  <method name="getTuple">
+   <arg type="u" direction="out"/>
+   <arg type="s" direction="out"/>
+  </method>
+  <method name="multiply">
+   <arg type="x" direction="in"/>
+   <arg type="d" direction="in"/>
+   <arg type="d" direction="out"/>
+  </method>
+  <method name="multiplyWithNoReply">
+   <arg type="x" direction="in"/>
+   <arg type="d" direction="in"/>
+   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+   <annotation name="org.freedesktop.DBus.Method.NoReply" value="true"/>
+  </method>
+  <method name="noArgNoReturn">
+  </method>
+  <method name="processVariant">
+   <arg type="v" direction="in"/>
+   <arg type="v" direction="out"/>
+  </method>
+  <method name="sumStructItems">
+   <arg type="(yq)" direction="in"/>
+   <arg type="(ix)" direction="in"/>
+   <arg type="i" direction="out"/>
+  </method>
+  <method name="sumVectorItems">
+   <arg type="aq" direction="in"/>
+   <arg type="at" direction="in"/>
+   <arg type="u" direction="out"/>
+  </method>
+  <method name="throwError">
+  </method>
+  <method name="throwErrorWithNoReply">
+   <annotation name="org.freedesktop.DBus.Method.NoReply" value="true"/>
+  </method>
+  <signal name="signalWithMap">
+   <arg type="a{is}"/>
+  </signal>
+  <signal name="signalWithVariant">
+   <arg type="v"/>
+  </signal>
+  <signal name="simpleSignal">
+   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+  </signal>
+  <property name="action" type="u" access="readwrite">
+   <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="false"/>
+  </property>
+  <property name="blocking" type="b" access="readwrite">
+  </property>
+  <property name="state" type="s" access="read">
+   <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+   <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="const"/>
+  </property>
+ </interface>
+</node>
+)delimiter";
+    }
+
 };
 
 

test/integrationtests/proxy-glue.h

@@ -45,7 +45,6 @@ protected:
                 { this->onSignalWithoutRegistration(s); });
     }
 
-
     virtual void onSimpleSignal() = 0;
     virtual void onSignalWithMap(const std::map<int32_t, std::string>& map) = 0;
     virtual void onSignalWithVariant(const sdbus::Variant& v) = 0;
@@ -78,6 +77,11 @@ public:
         return result;
     }
 
+    void multiplyWithNoReply(const int64_t& a, const double& b)
+    {
+        object_.callMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withArguments(a, b).dontExpectReply();
+    }
+
     std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x)
     {
         std::vector<int16_t> result;
@@ -155,6 +159,16 @@ public:
         return result;
     }
 
+    void throwError()
+    {
+        object_.callMethod("throwError").onInterface(INTERFACE_NAME);
+    }
+
+    void throwErrorWithNoReply()
+    {
+        object_.callMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).dontExpectReply();
+    }
+
     int32_t callNonexistentMethod()
     {
         int32_t result;
@@ -165,7 +179,7 @@ public:
     int32_t callMethodOnNonexistentInterface()
     {
         int32_t result;
-        object_.callMethod("someMethod").onInterface("interfaceThatDoesNotExist").storeResultsTo(result);
+        object_.callMethod("someMethod").onInterface("sdbuscpp.interface.that.does.not.exist").storeResultsTo(result);
         return result;
     }
 

test/perftests/client.cpp

@@ -0,0 +1,162 @@
+/**
+ * (C) 2019 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file client.cpp
+ *
+ * Created on: Jan 25, 2019
+ * 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 "perftest-proxy.h"
+#include <sdbus-c++/sdbus-c++.h>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <unistd.h>
+#include <thread>
+#include <chrono>
+#include <cassert>
+
+using namespace std::chrono_literals;
+
+class PerftestClient : public sdbus::ProxyInterfaces<org::sdbuscpp::perftest_proxy>
+{
+public:
+    PerftestClient(std::string destination, std::string objectPath)
+        : sdbus::ProxyInterfaces<org::sdbuscpp::perftest_proxy>(std::move(destination), std::move(objectPath))
+    {
+    }
+
+protected:
+    virtual void onDataSignal(const std::string& data) override
+    {
+        static unsigned int counter = 0;
+        static std::chrono::time_point<std::chrono::steady_clock> startTime;
+        
+        assert(data.size() == m_msgSize);
+        
+        ++counter;
+        
+        if (counter == 1)
+            startTime = std::chrono::steady_clock::now();
+        else if (counter == m_msgCount)
+        {
+            auto stopTime = std::chrono::steady_clock::now();
+            std::cout << "Received " << m_msgCount << " signals in: " << std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count() << " ms" << std::endl;
+            counter = 0;
+        }
+    }
+    
+public:
+    unsigned int m_msgSize{};
+    unsigned int m_msgCount{};
+};
+
+std::string createRandomString(size_t length)
+{
+    auto randchar = []() -> char
+    {
+        const char charset[] =
+        "0123456789"
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz";
+        const size_t max_index = (sizeof(charset) - 1);
+        return charset[ rand() % max_index ];
+    };
+    std::string str(length, 0);
+    std::generate_n(str.begin(), length, randchar);
+    return str;
+}
+
+
+//-----------------------------------------
+int main(int /*argc*/, char */*argv*/[])
+{
+    const char* destinationName = "org.sdbuscpp.perftest";
+    const char* objectPath = "/org/sdbuscpp/perftest";
+    PerftestClient client(destinationName, objectPath);
+
+    const unsigned int repetitions{20};
+    unsigned int msgCount = 1000;
+    unsigned int msgSize{};
+    
+    msgSize = 20;
+    std::cout << "** Measuring signals of size " << msgSize << " bytes (" << repetitions << " repetitions)..." << std::endl << std::endl;
+    client.m_msgCount = msgCount; client.m_msgSize = msgSize;
+    for (unsigned int r = 0; r < repetitions; ++r)
+    {
+        client.sendDataSignals(msgCount, msgSize);
+        
+        std::this_thread::sleep_for(1000ms);
+    }
+    
+    msgSize = 1000;
+    std::cout << std::endl << "** Measuring signals of size " << msgSize << " bytes (" << repetitions << " repetitions)..." << std::endl << std::endl;
+    client.m_msgCount = msgCount; client.m_msgSize = msgSize;
+    for (unsigned int r = 0; r < repetitions; ++r)
+    {
+        client.sendDataSignals(msgCount, msgSize);
+        
+        std::this_thread::sleep_for(1000ms);
+    }
+    
+    msgSize = 20;
+    std::cout << std::endl << "** Measuring method calls of size " << msgSize << " bytes (" << repetitions << " repetitions)..." << std::endl << std::endl;
+    for (unsigned int r = 0; r < repetitions; ++r)
+    {
+        auto str1 = createRandomString(msgSize/2);
+        auto str2 = createRandomString(msgSize/2);
+        
+        auto startTime = std::chrono::steady_clock::now();
+        for (unsigned int i = 0; i < msgCount; i++)
+        {
+            auto result = client.concatenateTwoStrings(str1, str2);
+            
+            assert(result.size() == str1.size() + str2.size());
+            assert(result.size() == msgSize);
+        }
+        auto stopTime = std::chrono::steady_clock::now();
+        std::cout << "Called " << msgCount << " methods in: " << std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count() << " ms" << std::endl;
+        
+        std::this_thread::sleep_for(1000ms);
+    }
+    
+    msgSize = 1000;
+    std::cout << std::endl << "** Measuring method calls of size " << msgSize << " bytes (" << repetitions << " repetitions)..." << std::endl << std::endl;
+    for (unsigned int r = 0; r < repetitions; ++r)
+    {
+        auto str1 = createRandomString(msgSize/2);
+        auto str2 = createRandomString(msgSize/2);
+        
+        auto startTime = std::chrono::steady_clock::now();
+        for (unsigned int i = 0; i < msgCount; i++)
+        {
+            auto result = client.concatenateTwoStrings(str1, str2);
+            
+            assert(result.size() == str1.size() + str2.size());
+            assert(result.size() == msgSize);
+        }
+        auto stopTime = std::chrono::steady_clock::now();
+        std::cout << "Called " << msgCount << " methods in: " << std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count() << " ms" << std::endl;
+        
+        std::this_thread::sleep_for(1000ms);
+    }
+    
+    return 0;
+}

test/perftests/files/org.sdbuscpp.perftest.conf

@@ -0,0 +1,16 @@
+<!-- This configuration file specifies the required security policies
+     for the Kistler DBUS example to run core daemon to work. -->
+
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+
+  <!-- ../system.conf have denied everything, so we just punch some holes -->
+
+  <policy context="default">
+    <allow own="org.sdbuscpp.perftest"/>
+    <allow send_destination="org.sdbuscpp.perftest"/>
+    <allow send_interface="org.sdbuscpp.perftest"/>
+  </policy>
+
+</busconfig>

test/perftests/org.sdbuscpp.perftest.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<node name="/org/sdbuscpp/perftest">
+    <interface name="org.sdbuscpp.perftest">
+        <method name="sendDataSignals">
+            <arg type="u" name="numberOfSignals" direction="in" />
+            <arg type="u" name="signalMsgSize" direction="in" />
+        </method>
+        <method name="concatenateTwoStrings">
+            <arg type="s" name="string1" direction="in" />
+            <arg type="s" name="string2" direction="in" />
+            <arg type="s" name="result" direction="out" />
+        </method>
+        <signal name="dataSignal">
+            <arg type="s" name="data" />
+        </signal>
+    </interface>
+</node>

test/perftests/perftest-adaptor.h

@@ -0,0 +1,46 @@
+
+/*
+ * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__perftest_adaptor_h__adaptor__H__
+#define __sdbuscpp__perftest_adaptor_h__adaptor__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+
+class perftest_adaptor
+{
+public:
+    static constexpr const char* interfaceName = "org.sdbuscpp.perftest";
+
+protected:
+    perftest_adaptor(sdbus::IObject& object)
+        : object_(object)
+    {
+        object_.registerMethod("sendDataSignals").onInterface(interfaceName).implementedAs([this](const uint32_t& numberOfSignals, const uint32_t& signalMsgSize){ return this->sendDataSignals(numberOfSignals, signalMsgSize); });
+        object_.registerMethod("concatenateTwoStrings").onInterface(interfaceName).implementedAs([this](const std::string& string1, const std::string& string2){ return this->concatenateTwoStrings(string1, string2); });
+        object_.registerSignal("dataSignal").onInterface(interfaceName).withParameters<std::string>();
+    }
+
+public:
+    void dataSignal(const std::string& data)
+    {
+        object_.emitSignal("dataSignal").onInterface(interfaceName).withArguments(data);
+    }
+
+private:
+    virtual void sendDataSignals(const uint32_t& numberOfSignals, const uint32_t& signalMsgSize) = 0;
+    virtual std::string concatenateTwoStrings(const std::string& string1, const std::string& string2) = 0;
+
+private:
+    sdbus::IObject& object_;
+};
+
+}} // namespaces
+
+#endif

test/perftests/perftest-proxy.h

@@ -0,0 +1,49 @@
+
+/*
+ * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__perftest_proxy_h__proxy__H__
+#define __sdbuscpp__perftest_proxy_h__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+
+class perftest_proxy
+{
+public:
+    static constexpr const char* interfaceName = "org.sdbuscpp.perftest";
+
+protected:
+    perftest_proxy(sdbus::IObjectProxy& object)
+        : object_(object)
+    {
+        object_.uponSignal("dataSignal").onInterface(interfaceName).call([this](const std::string& data){ this->onDataSignal(data); });
+    }
+
+    virtual void onDataSignal(const std::string& data) = 0;
+
+public:
+    void sendDataSignals(const uint32_t& numberOfSignals, const uint32_t& signalMsgSize)
+    {
+        object_.callMethod("sendDataSignals").onInterface(interfaceName).withArguments(numberOfSignals, signalMsgSize);
+    }
+
+    std::string concatenateTwoStrings(const std::string& string1, const std::string& string2)
+    {
+        std::string result;
+        object_.callMethod("concatenateTwoStrings").onInterface(interfaceName).withArguments(string1, string2).storeResultsTo(result);
+        return result;
+    }
+
+private:
+    sdbus::IObjectProxy& object_;
+};
+
+}} // namespaces
+
+#endif

test/perftests/server.cpp

@@ -0,0 +1,94 @@
+/**
+ * (C) 2019 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file server.cpp
+ *
+ * Created on: Jan 25, 2019
+ * 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 "perftest-adaptor.h"
+#include <sdbus-c++/sdbus-c++.h>
+#include <vector>
+#include <string>
+#include <thread>
+#include <chrono>
+
+using namespace std::chrono_literals;
+
+std::string createRandomString(size_t length);
+
+class PerftestServer : public sdbus::Interfaces<org::sdbuscpp::perftest_adaptor>
+{
+public:
+    PerftestServer(sdbus::IConnection& connection, std::string objectPath)
+        : sdbus::Interfaces<org::sdbuscpp::perftest_adaptor>(connection, std::move(objectPath))
+    {
+    }
+
+protected:
+    virtual void sendDataSignals(const uint32_t& numberOfSignals, const uint32_t& signalMsgSize) override
+    {
+        auto data = createRandomString(signalMsgSize);
+        char digits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
+        
+        auto start_time = std::chrono::steady_clock::now();
+        for (uint32_t i = 0; i < numberOfSignals; ++i)
+        {
+            // Emit signal
+            dataSignal(data);
+        }
+        auto stop_time = std::chrono::steady_clock::now();
+        std::cout << "Server sent " << numberOfSignals << " signals in: " << std::chrono::duration_cast<std::chrono::milliseconds>(stop_time - start_time).count() << " ms" << std::endl;
+    }
+    
+    virtual std::string concatenateTwoStrings(const std::string& string1, const std::string& string2) override
+    {
+        return string1 + string2;
+    }
+};
+
+std::string createRandomString(size_t length)
+{
+    auto randchar = []() -> char
+    {
+        const char charset[] =
+        "0123456789"
+        "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+        "abcdefghijklmnopqrstuvwxyz";
+        const size_t max_index = (sizeof(charset) - 1);
+        return charset[ rand() % max_index ];
+    };
+    std::string str(length, 0);
+    std::generate_n(str.begin(), length, randchar);
+    return str;
+}
+
+
+//-----------------------------------------
+int main(int /*argc*/, char */*argv*/[])
+{
+    const char* serviceName = "org.sdbuscpp.perftest";
+    auto connection = sdbus::createSystemBusConnection(serviceName);
+
+    const char* objectPath = "/org/sdbuscpp/perftest";
+    PerftestServer server(*connection, objectPath);
+
+    connection->enterProcessingLoop();
+}

test/unittests/Connection_test.cpp

@@ -0,0 +1,148 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file Connection_test.cpp
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Feb 4, 2019
+ * 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 "Connection.h"
+#include "unittests/mocks/SdBusMock.h"
+
+#include <gtest/gtest.h>
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::SetArgPointee;
+using ::testing::Return;
+using ::testing::NiceMock;
+
+using BusType = sdbus::internal::Connection::BusType;
+
+
+class ConnectionCreationTest : public ::testing::Test
+{
+protected:
+    ConnectionCreationTest() = default;
+
+    std::unique_ptr<NiceMock<SdBusMock>> mock_ { std::make_unique<NiceMock<SdBusMock>>() };
+    sd_bus* STUB_ { reinterpret_cast<sd_bus*>(1) };
+};
+
+using ASystemBusConnection = ConnectionCreationTest;
+using ASessionBusConnection = ConnectionCreationTest;
+
+TEST_F(ASystemBusConnection, OpensAndFlushesBusWhenCreated)
+{
+    EXPECT_CALL(*mock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(STUB_), Return(1)));
+    EXPECT_CALL(*mock_, sd_bus_flush(_)).Times(1);
+    sdbus::internal::Connection(BusType::eSystem, std::move(mock_));
+}
+
+TEST_F(ASessionBusConnection, OpensAndFlushesBusWhenCreated)
+{
+    EXPECT_CALL(*mock_, sd_bus_open_user(_)).WillOnce(DoAll(SetArgPointee<0>(STUB_), Return(1)));
+    EXPECT_CALL(*mock_, sd_bus_flush(_)).Times(1);
+    sdbus::internal::Connection(BusType::eSession, std::move(mock_));
+}
+
+TEST_F(ASystemBusConnection, ClosesAndUnrefsBusWhenDestructed)
+{
+    ON_CALL(*mock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(1)));
+    EXPECT_CALL(*mock_, sd_bus_flush_close_unref(_)).Times(1);
+    sdbus::internal::Connection(BusType::eSession, std::move(mock_));
+}
+
+TEST_F(ASessionBusConnection, ClosesAndUnrefsBusWhenDestructed)
+{
+    ON_CALL(*mock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(1)));
+    EXPECT_CALL(*mock_, sd_bus_flush_close_unref(_)).Times(1);
+    sdbus::internal::Connection(BusType::eSession, std::move(mock_));
+}
+
+TEST_F(ASystemBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
+{
+    ON_CALL(*mock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(-1)));
+    ASSERT_THROW(sdbus::internal::Connection(BusType::eSystem, std::move(mock_)), sdbus::Error);
+}
+
+TEST_F(ASessionBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
+{
+    ON_CALL(*mock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(-1)));
+    ASSERT_THROW(sdbus::internal::Connection(BusType::eSession, std::move(mock_)), sdbus::Error);
+}
+
+TEST_F(ASystemBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
+{
+    ON_CALL(*mock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(1)));
+    ON_CALL(*mock_, sd_bus_flush(_)).WillByDefault(Return(-1));
+    ASSERT_THROW(sdbus::internal::Connection(BusType::eSystem, std::move(mock_)), sdbus::Error);
+}
+
+TEST_F(ASessionBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
+{
+    ON_CALL(*mock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(1)));
+    ON_CALL(*mock_, sd_bus_flush(_)).WillByDefault(Return(-1));
+    ASSERT_THROW(sdbus::internal::Connection(BusType::eSession, std::move(mock_)), sdbus::Error);
+}
+
+class ConnectionRequestTest : public ::testing::TestWithParam<BusType>
+{
+protected:
+    ConnectionRequestTest() = default;
+    void SetUp() override
+    {
+        switch (GetParam())
+        {
+            case BusType::eSystem:
+                EXPECT_CALL(*mock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(STUB_), Return(1)));
+                break;
+            case BusType::eSession:
+                EXPECT_CALL(*mock_, sd_bus_open_user(_)).WillOnce(DoAll(SetArgPointee<0>(STUB_), Return(1)));
+                break;
+            default:
+                break;
+        }
+        ON_CALL(*mock_, sd_bus_flush(_)).WillByDefault(Return(1));
+        ON_CALL(*mock_, sd_bus_flush_close_unref(_)).WillByDefault(Return(STUB_));
+    }
+
+    std::unique_ptr<NiceMock<SdBusMock>> mock_ { std::make_unique<NiceMock<SdBusMock>>() };
+    sd_bus* STUB_ { reinterpret_cast<sd_bus*>(1) };
+};
+
+using AConnectionNameRequest = ConnectionRequestTest;
+
+TEST_P(AConnectionNameRequest, DoesNotThrowOnSuccess)
+{
+    EXPECT_CALL(*mock_, sd_bus_request_name(_, _, _)).WillOnce(Return(1));
+    sdbus::internal::Connection(GetParam(), std::move(mock_)).requestName("");
+}
+
+TEST_P(AConnectionNameRequest, ThrowsOnFail)
+{
+    EXPECT_CALL(*mock_, sd_bus_request_name(_, _, _)).WillOnce(Return(-1));
+
+    auto conn_ = sdbus::internal::Connection(GetParam(), std::move(mock_)) ;
+    ASSERT_THROW(conn_.requestName(""), sdbus::Error);
+}
+
+INSTANTIATE_TEST_SUITE_P(Request, AConnectionNameRequest, ::testing::Values(BusType::eSystem, BusType::eSession));

test/unittests/Types_test.cpp

@@ -212,3 +212,31 @@ TEST(AStruct, CreatesStructFromTuple)
     ASSERT_THAT(std::get<0>(valueStruct), Eq(std::get<0>(value)));
     ASSERT_THAT(std::get<1>(valueStruct), Eq(std::get<1>(value)));
 }
+
+TEST(AnObjectPath, CanBeConstructedFromCString)
+{
+    const char* aPath = "/some/path";
+
+    ASSERT_THAT(sdbus::ObjectPath{aPath}, Eq(aPath));
+}
+
+TEST(AnObjectPath, CanBeConstructedFromStdString)
+{
+    std::string aPath{"/some/path"};
+
+    ASSERT_THAT(sdbus::ObjectPath{aPath}, Eq(aPath));
+}
+
+TEST(ASignature, CanBeConstructedFromCString)
+{
+    const char* aSignature = "us";
+
+    ASSERT_THAT(sdbus::Signature{aSignature}, Eq(aSignature));
+}
+
+TEST(ASignature, CanBeConstructedFromStdString)
+{
+    std::string aSignature{"us"};
+
+    ASSERT_THAT(sdbus::Signature{aSignature}, Eq(aSignature));
+}

test/unittests/mocks/SdBusMock.h

@@ -0,0 +1,55 @@
+/**
+ * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file SdBusMock.h
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Mar 12, 2019
+ * 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/>.
+ */
+
+#ifndef SDBUS_CXX_SDBUS_MOCK_H
+#define SDBUS_CXX_SDBUS_MOCK_H
+
+#include "ISdBus.h"
+
+#include <gmock/gmock.h>
+
+class SdBusMock : public sdbus::internal::ISdBus
+{
+public:
+    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_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_METHOD1(sd_bus_slot_unref, sd_bus_slot*(sd_bus_slot *slot));
+    MOCK_METHOD6(sd_bus_message_new_method_call, int(sd_bus *bus, sd_bus_message **m, const char *destination, const char *path, const char *interface, const char *member));
+    MOCK_METHOD1(sd_bus_message_unref, sd_bus_message* (sd_bus_message *m));
+    MOCK_METHOD5(sd_bus_message_new_signal, int(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member));
+    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));
+    MOCK_METHOD1(sd_bus_open_user, int(sd_bus **ret));
+    MOCK_METHOD1(sd_bus_open_system, int(sd_bus **ret));
+    MOCK_METHOD1(sd_bus_flush, int(sd_bus *bus));
+    MOCK_METHOD2(sd_bus_process, int(sd_bus *bus, sd_bus_message **r));
+    MOCK_METHOD1(sd_bus_get_fd, int(sd_bus *bus));
+    MOCK_METHOD1(sd_bus_get_events, int(sd_bus *bus));
+    MOCK_METHOD2(sd_bus_get_timeout, int(sd_bus *bus, uint64_t *timeout_usec));
+    MOCK_METHOD1(sd_bus_flush_close_unref, sd_bus *(sd_bus *bus));
+};
+
+#endif //SDBUS_CXX_SDBUS_MOCK_H