Dont use deprecated api

This works whether `BUILD_LIBSYSTEMD` is `ON` or the separate build of
libsystemd picked up by pkg-config is static. The Gentoo Linux package
requires the latter.

This change also handles `BUILD_SHARED_LIBS` being `OFF`. In this case,
the libsystemd dependency does need to be included, even though it is
static.

CMake does not allow you to build shared and static libraries
simultaneously (with a single `add_library` call), but this change
declares the libsystemd dependency as `Requires.private` rather than
omitting it entirely. This is in case someone builds and installs both a
static and shared build and then calls `pkg-config --static sdbus-c++`.
The static build needs to be installed first so that the pkg-config
file from the shared build takes precedence.

.github/workflows/ci.yml

@@ -0,0 +1,82 @@
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-18.04, ubuntu-20.04]
+        compiler: [g++, clang]
+        build: [shared-libsystemd]
+        include:
+          - os: ubuntu-20.04
+            compiler: g++
+            build: embedded-static-libsystemd
+    steps:
+    - uses: actions/checkout@v2
+    - name: install-libsystemd-toolchain
+      if: matrix.build == 'embedded-static-libsystemd'
+      run: |
+        sudo apt-get update -y
+        sudo apt-get install -y meson ninja-build libcap-dev libmount-dev m4 gperf
+    - name: install-libsystemd-dev
+      if: matrix.build == 'shared-libsystemd'
+      run: |
+        sudo apt-get update -y
+        sudo apt-get install -y libsystemd-dev
+    - name: install-clang
+      if: matrix.compiler == 'clang'
+      run: |
+        sudo apt-get install -y clang
+        sudo update-alternatives --remove-all cc
+        sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang 10
+        sudo update-alternatives --remove-all c++
+        sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 10
+    - name: configure-debug
+      if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-18.04'
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="-O0 -g -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
+    - name: configure-release
+      if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-20.04'
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_CXX_FLAGS="-O3 -DNDEBUG -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
+    - name: configure-with-embedded-libsystemd
+      if: matrix.build == 'embedded-static-libsystemd'
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON -DBUILD_LIBSYSTEMD=ON -DLIBSYSTEMD_VERSION=244 ..
+    - name: make
+      run: |
+        cd build
+        cmake --build . -j2
+    - name: verify
+      run: |
+        cd build
+        sudo cmake --build . --target install
+        ctest
+    - name: pack
+      if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-20.04'
+      run: |
+        cd build
+        cpack -G DEB
+    - name: 'Upload Artifact'
+      if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-20.04' && matrix.compiler == 'g++'
+      uses: actions/upload-artifact@v2
+      with:
+        name: "debian-packages-${{ matrix.os }}-${{ matrix.compiler }}"
+        path: |
+          build/sdbus-c++*.deb
+          build/sdbus-c++*.ddeb
+        retention-days: 10

CMakeLists.txt

@@ -2,9 +2,9 @@
 # PROJECT INFORMATION
 #-------------------------------
 
-cmake_minimum_required(VERSION 3.6)
+cmake_minimum_required(VERSION 3.13)
 
-project(sdbus-c++ VERSION 0.7.7 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 1.2.0 LANGUAGES C CXX)
 
 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file
 
@@ -16,17 +16,25 @@ option(BUILD_LIBSYSTEMD "Build libsystemd static library and incorporate it into
 
 if(NOT BUILD_LIBSYSTEMD)
     find_package(PkgConfig REQUIRED)
-    pkg_check_modules(SYSTEMD libsystemd>=236)
-    if(NOT SYSTEMD_FOUND)
+    pkg_check_modules(Systemd IMPORTED_TARGET GLOBAL libsystemd>=236)
+    if(NOT TARGET PkgConfig::Systemd)
         message(FATAL_ERROR "libsystemd of version at least 236 is required, but was not found "
-                            "(you may turn BUILD_LIBSYSTEMD on for sdbus-c++ to try downloading "
-                            "and building libsystemd in as part of sdbus-c++ during configuration)")
+                            "(if you have systemd in your OS, you may want to install package containing pkgconfig "
+                            " files for libsystemd library. On Ubuntu, that is libsystemd-dev. "
+                            " Alternatively, you may turn BUILD_LIBSYSTEMD on for sdbus-c++ to download, build "
+                            "and incorporate libsystemd as embedded library within sdbus-c++)")
     endif()
+    add_library(Systemd::Libsystemd ALIAS PkgConfig::Systemd)
+    string(REGEX MATCHALL "([0-9]+)" SYSTEMD_VERSION_LIST "${Systemd_VERSION}")
+    list(GET SYSTEMD_VERSION_LIST 0 LIBSYSTEMD_VERSION)
+    message(STATUS "Building with libsystemd v${LIBSYSTEMD_VERSION}")
 else()
     # Build static libsystemd library as an external project
     include(cmake/LibsystemdExternalProject.cmake)
 endif()
 
+find_package(Threads REQUIRED)
+
 #-------------------------------
 # SOURCE FILES CONFIGURATION
 #-------------------------------
@@ -50,6 +58,7 @@ set(SDBUSCPP_HDR_SRCS
     ${SDBUSCPP_SOURCE_DIR}/Connection.h
     ${SDBUSCPP_SOURCE_DIR}/IConnection.h
     ${SDBUSCPP_SOURCE_DIR}/MessageUtils.h
+    ${SDBUSCPP_SOURCE_DIR}/Utils.h
     ${SDBUSCPP_SOURCE_DIR}/Object.h
     ${SDBUSCPP_SOURCE_DIR}/Proxy.h
     ${SDBUSCPP_SOURCE_DIR}/ScopeGuard.h
@@ -72,6 +81,7 @@ set(SDBUSCPP_PUBLIC_HDRS
     ${SDBUSCPP_INCLUDE_DIR}/Types.h
     ${SDBUSCPP_INCLUDE_DIR}/TypeTraits.h
     ${SDBUSCPP_INCLUDE_DIR}/Flags.h
+    ${SDBUSCPP_INCLUDE_DIR}/SdbusAsio.h
     ${SDBUSCPP_INCLUDE_DIR}/sdbus-c++.h)
 
 set(SDBUSCPP_SRCS ${SDBUSCPP_CPP_SRCS} ${SDBUSCPP_HDR_SRCS} ${SDBUSCPP_PUBLIC_HDRS})
@@ -80,11 +90,7 @@ set(SDBUSCPP_SRCS ${SDBUSCPP_CPP_SRCS} ${SDBUSCPP_HDR_SRCS} ${SDBUSCPP_PUBLIC_HD
 # GENERAL COMPILER CONFIGURATION
 #-------------------------------
 
-if(${CMAKE_VERSION} VERSION_LESS "3.8.0") 
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++17")
-else()
-    set(CMAKE_CXX_STANDARD 17) # Supported in CMake>=3.8
-endif()
+set(CMAKE_CXX_STANDARD 17)
 
 #----------------------------------
 # LIBRARY BUILD INFORMATION
@@ -93,22 +99,28 @@ endif()
 set(SDBUSCPP_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
 set(SDBUSCPP_VERSION "${PROJECT_VERSION}")
 
-option(BUILD_SHARED_LIBS "Build shared libraries (.so) instead of static ones (.a)" ON)
+# We promote BUILD_SHARED_LIBS flags to (global) option only if we are the main project
+if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
+    option(BUILD_SHARED_LIBS "Build shared libraries (.so) instead of static ones (.a)" ON)
+endif()
 
 # Having an object target allows unit tests to reuse already built sources without re-building
 add_library(sdbus-c++-objlib OBJECT ${SDBUSCPP_SRCS})
-target_compile_definitions(sdbus-c++-objlib PRIVATE BUILD_LIB=1 LIBSYSTEMD_VERSION=${SYSTEMD_VERSION})
+target_compile_definitions(sdbus-c++-objlib PRIVATE BUILD_LIB=1 LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
 target_include_directories(sdbus-c++-objlib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
-                                                   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>
-                                                   $<BUILD_INTERFACE:${SYSTEMD_INCLUDE_DIRS}>)
-if(BUILD_SHARED_LIBS)
-    set_target_properties(sdbus-c++-objlib PROPERTIES POSITION_INDEPENDENT_CODE ON)
+                                                   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/src>)
+if(DEFINED BUILD_SHARED_LIBS)
+    set_target_properties(sdbus-c++-objlib PROPERTIES POSITION_INDEPENDENT_CODE ${BUILD_SHARED_LIBS})
 endif()
 if(BUILD_LIBSYSTEMD)
     add_dependencies(sdbus-c++-objlib LibsystemdBuildProject)
 endif()
+target_link_libraries(sdbus-c++-objlib
+        PUBLIC
+            Systemd::Libsystemd
+            Threads::Threads)
 
-add_library(sdbus-c++ $<TARGET_OBJECTS:sdbus-c++-objlib>)
+add_library(sdbus-c++)
 target_include_directories(sdbus-c++ PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
                                             $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
 set_target_properties(sdbus-c++
@@ -116,17 +128,21 @@ set_target_properties(sdbus-c++
                                  VERSION "${SDBUSCPP_VERSION}"
                                  SOVERSION "${SDBUSCPP_VERSION_MAJOR}"
                                  OUTPUT_NAME "sdbus-c++")
-target_link_libraries(sdbus-c++ PRIVATE ${SYSTEMD_LIBRARIES})
+target_link_libraries(sdbus-c++ PRIVATE sdbus-c++-objlib)
 
 #----------------------------------
 # INSTALLATION
 #----------------------------------
+set(EXPORT_SET sdbus-c++)
+if(NOT BUILD_SHARED_LIBS)
+    list(APPEND EXPORT_SET "sdbus-c++-objlib")
+endif()
 
-install(TARGETS sdbus-c++
+install(TARGETS ${EXPORT_SET}
         EXPORT sdbus-c++-targets
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT libraries
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT libraries
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT static_libraries
+        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT runtime
+        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT runtime
+        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT dev
         PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${SDBUSCPP_INCLUDE_SUBDIR} COMPONENT dev)
 
 #----------------------------------
@@ -136,6 +152,7 @@ install(TARGETS sdbus-c++
 option(BUILD_TESTS "Build and install tests (default OFF)" OFF)
 
 if(BUILD_TESTS)
+    message(STATUS "Building with tests")
     enable_testing()
     add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/tests")
 endif()
@@ -147,9 +164,21 @@ endif()
 option(BUILD_CODE_GEN "Build and install interface stub code generator (default OFF)" OFF)
 
 if(BUILD_CODE_GEN)
+    message(STATUS "Building with code generator tool")
     add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/tools")
 endif()
 
+#----------------------------------
+# EXAMPLES
+#----------------------------------
+
+option(BUILD_EXAMPLES "Build example programs (default OFF)" OFF)
+
+if(BUILD_EXAMPLES)
+    message(STATUS "Building with examples")
+    add_subdirectory(examples)
+endif()
+
 #----------------------------------
 # DOCUMENTATION
 #----------------------------------
@@ -157,9 +186,10 @@ endif()
 option(BUILD_DOC "Build documentation for sdbus-c++" ON)
 
 if(BUILD_DOC)
+    message(STATUS "Building with documentation")
     option(BUILD_DOXYGEN_DOC "Build doxygen documentation for sdbus-c++ API" OFF)
     add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/docs")
-    install(FILES README README.md NEWS COPYING ChangeLog AUTHORS DESTINATION ${CMAKE_INSTALL_DOCDIR})
+    install(FILES README README.md NEWS COPYING ChangeLog AUTHORS DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT doc)
 endif()
 
 #----------------------------------
@@ -181,6 +211,33 @@ install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-config.cmake
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++
         COMPONENT dev)
 
+if(BUILD_SHARED_LIBS AND (BUILD_LIBSYSTEMD OR Systemd_LINK_LIBRARIES MATCHES "/libsystemd\.a(;|$)"))
+    set(PKGCONFIG_REQS ".private")
+else()
+    set(PKGCONFIG_REQS "")
+endif()
 configure_file(pkgconfig/sdbus-c++.pc.in pkgconfig/sdbus-c++.pc @ONLY)
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/sdbus-c++.pc
         DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT dev)
+
+#----------------------------------
+# CPack
+#----------------------------------
+set(CPACK_PACKAGE_VENDOR "Kistler")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "high-level C++ D-Bus library")
+set(CPACK_PACKAGE_CONTACT "info@kistler.com")
+set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
+set(CPACK_COMPONENTS_ALL runtime dev doc)
+set(CPACK_COMPONENT_DEV_DEPENDS "runtime")
+
+# specific for DEB generator
+set(CPACK_DEB_COMPONENT_INSTALL ON)
+set(CPACK_DEBIAN_RUNTIME_DEBUGINFO_PACKAGE ON)
+set(CPACK_DEBIAN_RUNTIME_PACKAGE_NAME ${PROJECT_NAME})
+set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
+set(CPACK_DEBIAN_PACKAGE_SECTION "libs")
+set(CPACK_DEBIAN_PACKAGE_SHLIBDEPS ON)
+set(CPACK_DEBIAN_ENABLE_COMPONENT_DEPENDS ON)
+set(CPACK_DEBIAN_DEV_PACKAGE_DEPENDS "libsystemd-dev (>=236)")
+
+include(CPack)

COPYING-LGPL-Exception

@@ -0,0 +1,22 @@
+sdbus-c++ LGPL Exception version 1.0
+
+As an additional permission to the GNU Lesser General Public License version
+2.1, the object code form of a "work that uses the Library" may incorporate
+material from a header file that is part of the Library.  You may distribute
+such object code under terms of your choice, provided that:
+    (i)   the header files of the Library have not been modified; and 
+    (ii)  the incorporated material is limited to numerical parameters, data
+          structure layouts, accessors, macros, inline functions and
+          templates; and
+    (iii) you comply with the terms of Section 6 of the GNU Lesser General
+          Public License version 2.1.
+
+Moreover, you may apply this exception to a modified version of the Library,
+provided that such modification does not involve copying material from the
+Library into the modified Library's header files unless such material is
+limited to (i) numerical parameters; (ii) data structure layouts;
+(iii) accessors; and (iv) small macros, templates and inline functions of
+five lines or less in length.
+
+Furthermore, you are not required to apply this additional permission to a
+modified version of the Library.

ChangeLog

@@ -135,3 +135,84 @@ v0.7.6
 v0.7.7
 - Fix race condition of polling on D-Bus fd from two threads (event loop thread and sync D-Bus call thread)
 - Little ordering fix in stress tests
+
+v0.7.8
+- Switch from thread_local to global bus instance that is used to create Variant instances (thread_local caused issues with Variant in very special inter-thread situations)
+
+v0.8.0
+- [[Breaking ABI change]]  Implement support for input & output parameter names for D-Bus methods and signals, which are used in introspection
+- Explain better in tutorial the design and how to use connections in relation to objects and proxies
+
+v0.8.1
+- Switch to full C++17 support
+- Switch to more modern CMake (>=3.12)
+- Provide better names to event loop-related IConnection methods, keep old ones marked as deprecated for backwards compatibility
+
+v0.8.2
+- Introduce support for cancellable async calls
+- Add getObjectPath() for proxy and object classes
+- Sanitize names of namespaces/methods/signals/properties/arguments in sdbus-c++-xml2cpp
+- Fix delivery of signals to multiple proxies subscribed to them
+- Fix file existence condition in sdbus-c++-xml2cpp
+- Fix CallData race condition in Proxy::callMethod
+- Fix integration tests for libsystemd older than 242
+- Fix installation of public sd-bus headers in internal libsystemd build
+- Fix integration test cases failing in specific situations
+- Fix build with clang 9.0.1 and libcxx
+- Fix potential data race in Proxy's condition variable
+
+v0.8.3
+- Fix build with gcc 8.3
+- Address a few inconsistencies and make code more idiomatic
+- Clean up integration tests
+- Remove non-virtual-dtor warnings by making classes final
+- Update CMake configuration flag names
+- Fix unused variable warning for release builds
+- Introduce CI workflow based on GitHub Actions
+
+v0.9.0
+- Provide CMake config and PkgConfig files for tools
+- Provide access to D-Bus message in high-level API
+- Add API to set signal destination
+- Add IProxy::getConnection() method
+- Add README and sdbus-c++ tutorial as additional pages in doxydocs
+- Enable default construction of PendingAsyncCall
+- Add API to get message path and message destination
+- Avoid propagating msg unpack exceptions to the event loop
+- Fix issue #145: signals are not filtered by sender
+- Fix race condition in Proxy and Object destructor
+- Fix seg fault in Message::peekType()
+- Add information to documentation about conan recipe
+- Add cpack to build debian packages, split the packages by components
+- Catch sdbus-c++ exceptions flying from Proxy callbacks to libsystemd
+- Add createDefaultBusConnection() method
+- Make resetting loop thread ID exception-safe
+- Support Error parameter in signal handlers
+- Add specific sections for tips and notes in the tutorial
+- A few additional documentation and test updates and improvements
+
+v1.0.0
+- [[Breaking API change]] Fixed the API to send org.freedesktop.DBus.ObjectManager.InterfacesAdded and org.freedesktop.DBus.ObjectManager.InterfacesRemoved signals via the generated stubs layer.
+  - StandardInterfaces.h: Split ObjectManager_adaptor and ManagedObject_adaptor.
+- New examples directory. First example covers the object manager. Further examples might follow.
+
+v1.1.0
+- Fix timeout handling for asynchronous method calls
+- Add support for unregistering signal handler
+- Add support for chrono literals in sdbus-c++-xml2cpp generator
+- Additional little fixes and improvements in code, build system, and documentation
+
+v1.2.0
+- Add support for match rules
+- Add support for session bus connection at custom address
+- Add CMake variable for extra libsystemd config options
+- Use pseudo D-Bus connection for plain messages
+- Rename dont_request_slot tag to floating_slot
+- Add validity checks for names and paths
+- Remove executable flag from source files
+- Detect missing type after array declaration
+- Fix invalid assert on event fd
+- Enable move for ObjectPath and Signature
+- Add printer for std::chrono in googletest v1.11.0
+- Fix potential undefined behavior in creation of sdbus::Error
+- Additional little fixes and improvements in code, build system, and documentation

README.md

@@ -1,6 +1,10 @@
 sdbus-c++
 =========
 
+![ci](https://github.com/Kistler-Group/sdbus-cpp/workflows/CI/badge.svg)
+![license](https://img.shields.io/github/license/Kistler-Group/sdbus-cpp)
+![release](https://img.shields.io/github/v/release/Kistler-Group/sdbus-cpp)
+
 sdbus-c++ is a high-level C++ D-Bus library for Linux designed to provide expressive, easy-to-use API in modern C++. It adds another layer of abstraction on top of sd-bus, a nice, fresh C D-Bus implementation by systemd.
 
 sdbus-c++ has been written primarily as a replacement of dbus-c++, which currently suffers from a number of (unresolved) bugs, concurrency issues and inherent design complexities and limitations. sdbus-c++ has learned from dbus-c++ and has chosen a different path, a path of simple yet powerful design that is intuitive and friendly to the user and inherently free of those bugs.
@@ -16,8 +20,8 @@ The library is built using CMake:
 $ mkdir build
 $ cd build
 $ cmake .. -DCMAKE_BUILD_TYPE=Release ${OTHER_CONFIG_FLAGS}
-$ make
-$ sudo make install
+$ cmake --build .
+$ sudo cmake --build . --target install
 ```
 
 ### CMake configuration flags for sdbus-c++
@@ -32,17 +36,17 @@ $ sudo make install
 
     * `BUILD_DOXYGEN_DOC` [boolean]
 
-      Option for building Doxygen documentation of sdbus-c++ API. If enabled, the documentation must still be built explicitly through `make doc`. Default value: `OFF`. Use `-DBUILD_DOXYGEN_DOC=OFF` to disable searching for Doxygen and building Doxygen documentation of sdbus-c++ API.
+      Option for building Doxygen documentation of sdbus-c++ API. If enabled, the documentation must still be built explicitly through `cmake --build . --target doc`. Default value: `OFF`. Use `-DBUILD_DOXYGEN_DOC=OFF` to disable searching for Doxygen and building Doxygen documentation of sdbus-c++ API.
 
 * `BUILD_TESTS` [boolean]
 
-  Option for building sdbus-c++ unit and integration tests, invokable by `make test`. That incorporates downloading and building static libraries of Google Test. Default value: `OFF`. Use `-DBUILD_TESTS=ON` to enable building the tests. With this option turned on, you may also enable/disable the following options:
+  Option for building sdbus-c++ unit and integration tests, invokable by `cmake --build . --target test` (Note: before invoking `cmake --build . --target test`, make sure you copy `tests/integrationtests/files/org.sdbuscpp.integrationtests.conf` file to `/etc/dbus-1/system.d` directory). That incorporates downloading and building static libraries of Google Test. Default value: `OFF`. Use `-DBUILD_TESTS=ON` to enable building the tests. With this option turned on, you may also enable/disable the following options:
 
-    * `BUILD_PERF_TESTS` [boolean]
+    * `ENABLE_PERF_TESTS` [boolean]
 
       Option for building sdbus-c++ performance tests. Default value: `OFF`.
 
-    * `BUILD_STRESS_TESTS` [boolean]
+    * `ENABLE_STRESS_TESTS` [boolean]
 
       Option for building sdbus-c++ stress tests. Default value: `OFF`.
 
@@ -58,22 +62,35 @@ $ sudo make install
 
       Defines version of systemd to be downloaded, built and integrated into sdbus-c++. Default value: `242`.
 
+    * `LIBSYSTEMD_EXTRA_CONFIG_OPTS` [string]
+
+      Additional options to be passed as-is to the libsystemd build system (meson for systemd v242) in its configure step. Can be used for passing e.g. toolchain file path in case of cross builds. Default value: empty.
+
 * `CMAKE_BUILD_TYPE` [string]
 
   This is a CMake-builtin option. Set to `Release` to build sdbus-c++ for production use. Set to `Debug` if you want to help further develop (and debug) the library :)
 
+* `BUILD_SHARED_LIBS` [boolean]
+
+  This is a global CMake flag, promoted in sdbus-c++ project to a CMake option. Use this to control whether sdbus-c++ is built as either a shared or static library. Default value: `ON`.
+
+* `BUILD_EXAMPLES` [boolean]
+
+  Build example programs which are located in the _example_ directory. Examples are not installed. Default value: `OFF`
+
 Dependencies
 ------------
 
-* `C++17` - the library uses C++17 `std::uncaught_exceptions()` feature. When building sdbus-c++ manually, make sure you use a compiler that supports that feature (gcc >= 6, clang >= 3.7)
+* `C++17` - the library uses C++17 features.
 * `libsystemd` - systemd library containing sd-bus implementation. This library is part of systemd. Systemd at least v236 is needed. (In case you have a non-systemd environment, don't worry, see [Solving libsystemd dependency](docs/using-sdbus-c++.md#solving-libsystemd-dependency) for more information.)
 * `googletest` - google unit testing framework, only necessary when building tests, will be downloaded and built automatically.
 * `pkgconfig` - required for sdbus-c++ to be able to find some dependency packages.
+* `expat` - necessary when building xml2cpp code generator (`BUILD_CODE_GEN` option is ON).
 
 Licensing
 ---------
 
-The library is distributed under LGPLv2.1 license.
+The library is distributed under LGPLv2.1 license, with a specific exception for macro/template/inline code in library header files.
 
 References/documentation
 ------------------------

cmake/LibsystemdExternalProject.cmake

@@ -1,10 +1,15 @@
 find_program(MESON meson)
 find_program(NINJA ninja)
+find_program(GPERF gperf)
 
 if((NOT MESON) OR (NOT NINJA))
     message(FATAL_ERROR "Meson and Ninja are required to build libsystemd")
 endif()
 
+if(NOT GPERF)
+    message(WARNING "gperf was not found, libsystemd configuration may fail")
+endif()
+
 find_library(GLIBC_RT_LIBRARY rt)
 find_package(PkgConfig REQUIRED)
 pkg_check_modules(MOUNT mount)
@@ -14,6 +19,7 @@ if (NOT CAP_FOUND)
 endif()
 
 set(LIBSYSTEMD_VERSION "242" CACHE STRING "libsystemd version (>=239) to build and incorporate into libsdbus-c++")
+set(LIBSYSTEMD_EXTRA_CONFIG_OPTS "" CACHE STRING "Additional configuration options to be passed as-is to libsystemd build system")
 
 if(NOT CMAKE_BUILD_TYPE)
     set(LIBSYSTEMD_BUILD_TYPE "plain")
@@ -30,28 +36,30 @@ if(LIBSYSTEMD_VERSION GREATER "240")
     set(BUILD_VERSION_H ${NINJA} -C <BINARY_DIR> version.h)
 endif()
 
+message(STATUS "Building with embedded libsystemd v${LIBSYSTEMD_VERSION}")
+
 include(ExternalProject)
 ExternalProject_Add(LibsystemdBuildProject
                     PREFIX libsystemd-v${LIBSYSTEMD_VERSION}
-                    GIT_REPOSITORY    https://github.com/systemd/systemd.git
-                    GIT_TAG           v${LIBSYSTEMD_VERSION}
+                    GIT_REPOSITORY    https://github.com/systemd/systemd-stable.git
+                    GIT_TAG           v${LIBSYSTEMD_VERSION}-stable
                     GIT_SHALLOW       1
                     UPDATE_COMMAND    ""
                     CONFIGURE_COMMAND ${CMAKE_COMMAND} -E remove <BINARY_DIR>/*
-                              COMMAND ${MESON} --buildtype=${LIBSYSTEMD_BUILD_TYPE} -Dstatic-libsystemd=pic <SOURCE_DIR> <BINARY_DIR>
+                              COMMAND ${MESON} --prefix=<INSTALL_DIR> --buildtype=${LIBSYSTEMD_BUILD_TYPE} -Dstatic-libsystemd=pic -Dselinux=false <SOURCE_DIR> <BINARY_DIR> ${LIBSYSTEMD_EXTRA_CONFIG_OPTS}
                     BUILD_COMMAND     ${BUILD_VERSION_H}
                           COMMAND     ${NINJA} -C <BINARY_DIR> libsystemd.a
-                    BUILD_ALWAYS      1
-                    INSTALL_COMMAND   ""
-                    LOG_DOWNLOAD 1 LOG_UPDATE 1 LOG_CONFIGURE 1 LOG_BUILD 1)
+                    BUILD_ALWAYS      0
+                    INSTALL_COMMAND   ${CMAKE_COMMAND} -E copy_directory <SOURCE_DIR>/src/systemd <INSTALL_DIR>/include/systemd
+                    LOG_DOWNLOAD 1 LOG_UPDATE 1 LOG_CONFIGURE 1 LOG_BUILD 1
+                    BUILD_BYPRODUCTS <BINARY_DIR>/libsystemd.a)
 
 ExternalProject_Get_property(LibsystemdBuildProject SOURCE_DIR)
-set(SYSTEMD_INCLUDE_DIRS ${SOURCE_DIR}/src)
 ExternalProject_Get_property(LibsystemdBuildProject BINARY_DIR)
-set(SYSTEMD_LIBRARY_DIRS ${BINARY_DIR})
-
-set(SYSTEMD_VERSION ${LIBSYSTEMD_VERSION})
+ExternalProject_Get_property(LibsystemdBuildProject INSTALL_DIR)
 
 add_library(Systemd::Libsystemd STATIC IMPORTED)
-set_target_properties(Systemd::Libsystemd PROPERTIES IMPORTED_LOCATION ${SYSTEMD_LIBRARY_DIRS}/libsystemd.a)
-set(SYSTEMD_LIBRARIES Systemd::Libsystemd ${CAP_LIBRARIES} ${GLIBC_RT_LIBRARY} ${MOUNT_LIBRARIES})
+set_target_properties(Systemd::Libsystemd PROPERTIES IMPORTED_LOCATION ${BINARY_DIR}/libsystemd.a)
+file(MAKE_DIRECTORY ${INSTALL_DIR}/include/systemd) # Trick for CMake to stop complaining about non-existent ${INSTALL_DIR}/include directory
+target_include_directories(Systemd::Libsystemd INTERFACE ${INSTALL_DIR}/include)
+target_link_libraries(Systemd::Libsystemd INTERFACE ${CAP_LIBRARIES} ${GLIBC_RT_LIBRARY} ${MOUNT_LIBRARIES})

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

@@ -2,10 +2,3 @@
 
 include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")
 check_required_components("@PROJECT_NAME@")
-
-# This is here for backwards-compatibility. Please use more modern target-based approach.
-set(SDBUSCPP_VERSION "@SDBUSCPP_VERSION@")
-set(SDBUSCPP_FOUND "TRUE")
-set_and_check(SDBUSCPP_INCLUDE_DIRS "@CMAKE_INSTALL_FULL_INCLUDEDIR@")
-set_and_check(SDBUSCPP_LIBRARY_DIR "@CMAKE_INSTALL_FULL_LIBDIR@")
-set(SDBUSCPP_LIBRARIES sdbus-c++)

docs/CMakeLists.txt

@@ -12,7 +12,11 @@ if(BUILD_DOXYGEN_DOC)
             COMMENT "Generating API documentation with Doxygen"
             VERBATIM)
 
-        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL)
+        # workaround bug https://github.com/doxygen/doxygen/pull/6787
+        add_custom_command(TARGET doc POST_BUILD
+          COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/sdbus-c++-class-diagram.png ${CMAKE_CURRENT_BINARY_DIR}/html/.)
+        
+        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL COMPONENT doc)
     else()
         message(WARNING "Documentation enabled, but Doxygen cannot be found")
     endif()
@@ -22,4 +26,4 @@ install(FILES sdbus-c++-class-diagram.png
               sdbus-c++-class-diagram.uml
               systemd-dbus-config.md
               using-sdbus-c++.md
-        DESTINATION ${CMAKE_INSTALL_DOCDIR})
+        DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT doc)

docs/Doxyfile.in

@@ -790,7 +790,9 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = "@CMAKE_CURRENT_SOURCE_DIR@/../include"
+INPUT                  = "@CMAKE_CURRENT_SOURCE_DIR@/../include" \
+                          @CMAKE_CURRENT_SOURCE_DIR@/../README.md \
+                          @CMAKE_CURRENT_SOURCE_DIR@/using-sdbus-c++.md
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
@@ -982,7 +984,7 @@ FILTER_SOURCE_PATTERNS =
 # (index.html). This can be useful if you have a project on for instance GitHub
 # and want to reuse the introduction page also for the doxygen output.
 
-USE_MDFILE_AS_MAINPAGE =
+USE_MDFILE_AS_MAINPAGE = README.md
 
 #---------------------------------------------------------------------------
 # Configuration options related to source browsing

docs/systemd-dbus-config.md

@@ -1,4 +1,4 @@
-Systemd and dbus configuration
+Systemd and D-Bus configuration
 =======================
 
 **Table of contents**
@@ -10,15 +10,13 @@ Systemd and 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.
+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) 
+Filename should use `.service` extension. It also must be placed in configuration directory (/etc/systemd/system in Ubuntu 18.04.1 LTS)
 
 ```
 [Unit]
@@ -31,12 +29,10 @@ ExecStart=/path/to/executable
 WantedBy=multi-user.target
 ```
 
-Dbus configuration
+D-Bus 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:
+Typical default D-Bus configuration does not allow to register services except explicitly allowed. To allow a service to register its D-Bus API, we must place an appropriate conf file in `/etc/dbus-1/system.d/` directory. The conf file name must be `<service-name>.conf`. I.e., full file path for Concatenator example from sdbus-c++ tutorial would be `/etc/dbus-1/system.d/org.sdbuscpp.concatenator.conf`. And here is template configuration to use its D-Bus interface under root:
 
 ```
 <!DOCTYPE busconfig PUBLIC
@@ -45,10 +41,10 @@ configuration to use dbus interface under root:
 <busconfig>
   <policy user="root">
     <allow own="org.sdbuscpp.concatenator"/>
-    <allow send_destination="org.sdbuscpp"/>
+    <allow send_destination="org.sdbuscpp.concatenator"/>
     <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`.
+If you need access from other user then `root` should be substituted by desired username. Or you can simply use policy `<policy context="default">` like [conf file](/tests/integrationtests/files/org.sdbuscpp.integrationtests.conf) for sdbus-c++ integration tests is doing it. For more information refer to `man dbus-daemon`.

docs/using-sdbus-c++.md

@@ -19,14 +19,15 @@ Using sdbus-c++ library
 14. [Asynchronous client-side methods](#asynchronous-client-side-methods)
 15. [Using D-Bus properties](#using-d-bus-properties)
 16. [Standard D-Bus interfaces](#standard-d-bus-interfaces)
-17. [Conclusion](#conclusion)
+17. [Support for match rules](#support-for-match-rules)
+18. [Conclusion](#conclusion)
 
 Introduction
 ------------
 
 sdbus-c++ is a C++ D-Bus library built on top of [sd-bus](http://0pointer.net/blog/the-new-sd-bus-api-of-systemd.html), a lightweight D-Bus client library implemented within [systemd](https://github.com/systemd/systemd) project. It provides D-Bus functionality on a higher level of abstraction, trying to employ C++ type system to shift as much work as possible from the developer to the compiler.
 
-sdbus-c++ does not cover the entire sd-bus API, but provides tools for implementing the most common functionality - RPC method calls, signals and properties. There is room for additions and improvements, as needed and when needed.
+Although sdbus-c++ covers most of sd-bus API, it does not (yet) fully cover every sd-bus API detail. The focus is put on the most widely used functionality: D-Bus connections, object, proxies, synchronous and asynchronous method calls, signals, and properties. If you are missing a desired functionality, you are welcome to submit an issue, or, best, to contribute to sdbus-c++ by submitting a pull request.
 
 Integrating sdbus-c++ into your project
 ---------------------------------------
@@ -51,7 +52,23 @@ PKG_CHECK_MODULES(SDBUSCPP, [sdbus-c++ >= 0.6],,
 )
 ```
 
-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.
+> **_Note_:** sdbus-c++ library uses a number of modern C++17 features. Please make certain you have a recent compiler (gcc >= 7, clang >= 6).
+
+If you intend to use stub generator (explained later) in your project to generate interface headers from XML, you can integrate that too with CMake or `pkg-config`:
+
+```cmake
+# First, find sdbus-c++-tools
+find_package(sdbus-c++-tools REQUIRED)
+
+# Use the sdbus-c++-xml2cpp in SDBusCpp namespace to generate the headers
+add_custom_command(
+    OUTPUT myproject-client-glue.h myproject-server-glue.h
+    COMMAND SDBusCpp::sdbus-c++-xml2cpp ${PROJECT_SOURCE_DIR}/dbus/myproject-bindings.xml
+        --proxy=myproject-client-glue.h --adaptor=myproject-server-glue.h
+    DEPENDS dbus/myproject-bindings.xml
+    COMMENT "Generating D-Bus interfaces for ${PROJECT_NAME}."
+)
+```
 
 Solving libsystemd dependency
 -----------------------------
@@ -82,31 +99,43 @@ $ ninja libsystemd.so.0.26.0  # or another version number depending which system
 
 ### Building and distributing libsystemd as part of sdbus-c++
 
-sdbus-c++ provides `BUILD_LIBSYSTEMD` configuration option. When turned on, sdbus-c++ will automatically download and build libsystemd as a static library and make it an opaque part of sdbus-c++ shared library for you. This is the most convenient and effective approach to build, distribute and use sdbus-c++ as a self-contained, systemd-independent library in non-systemd enviroments. Just make sure your build machine has all dependencies needed by libsystemd build process. That includes `meson`, `ninja`, `git` programs and mainly libraries and library headers for `libmount`, `libcap` and `librt` (part of glibc). Also when distributing, make sure these dependency libraries are installed on the production machine.
+sdbus-c++ provides `BUILD_LIBSYSTEMD` configuration option. When turned on, sdbus-c++ will automatically download and build libsystemd as a static library and make it an opaque part of sdbus-c++ shared library for you. This is the most convenient and effective approach to build, distribute and use sdbus-c++ as a self-contained, systemd-independent library in non-systemd enviroments. Just make sure your build machine has all dependencies needed by libsystemd build process. That includes, among others, `meson`, `ninja`, `git`, `gperf`, and -- primarily -- libraries and library headers for `libmount`, `libcap` and `librt` (part of glibc). Be sure to check out the systemd documentation for the  Also, when distributing, make sure these dependency libraries are installed on the production machine.
 
 You may additionally set the `LIBSYSTEMD_VERSION` configuration flag to fine-tune the version of systemd to be taken in. (The default value is 242).
 
 Distributing sdbus-c++
 ----------------------
 
-sdbus-c++ recipes for Yocto are available. Contributors willing to help with bringing sdbus-c++ to popular package systems are welcome.
-
 ### Yocto
 
-There are sdbus-c++ recipes for already released Yocto versions (for versions Sumo and newer) available in the meta-oe layer of meta-openembedded fork at Kistler-Group:
+There are Yocto recipes for sdbus-c++ available in the [`meta-oe`](https://github.com/openembedded/meta-openembedded/tree/master/meta-oe/recipes-core/sdbus-c%2B%2B) layer of the `meta-openembedded` project. There are two recipes:
 
-  * [sdbus-c++ recipes for Yocto Sumo](https://github.com/Kistler-Group/meta-openembedded/tree/sumo-with-sdbus-c%2B%2B/meta-oe/recipes-core/sdbus-c%2B%2B)
-  * [sdbus-c++ recipes for Yocto Thud](https://github.com/Kistler-Group/meta-openembedded/tree/thud-with-sdbus-c%2B%2B/meta-oe/recipes-core/sdbus-c%2B%2B)
-  * [sdbus-c++ recipes for Yocto Warrior](https://github.com/Kistler-Group/meta-openembedded/tree/warrior-with-sdbus-c%2B%2B/meta-oe/recipes-core/sdbus-c%2B%2B)
-
-Also, there is currently a pull request pending that pushes there recipes upstream -- to the OpenEmbedded project, so they will be officially available for the upcoming Yocto release.
-
-There are two recipes:
-
-  * One for sdbus-c++ itself. It detects whether systemd feature is turned on in the poky linux configuration. If so, it simply depends on systemd and makes use of libsystemd shared library available in the target system. Otherwise it automatically downloads and builds libsystemd static library and makes it an opaque part of sdbus-c++ shared library. The recipe also supports ptest.
+  * One for sdbus-c++ itself. It detects whether systemd feature is turned on in the poky linux configuration. If so, it simply depends on systemd and makes use of libsystemd shared library available in the target system. Otherwise it automatically downloads and builds libsystemd static library and links it into the sdbus-c++ shared library. The recipe also supports ptest.
   * One for sdbus-c++ native tools, namely sdbus-c++ code generator to generate C++ adaptor and proxy binding classes.
 
-Tip: If you get `ERROR: Program or command 'getent' not found or not executable` when building sdbus-c++ in Yocto, please make sure you've added `getent` to `HOSTTOOLS`. For example, you can add `HOSTTOOLS_NONFATAL += "getent"` into your local.conf file.
+> **_Tip_:** If you get `ERROR: Program or command 'getent' not found or not executable` when building sdbus-c++ in Yocto, please make sure you've added `getent` to `HOSTTOOLS`. For example, you can add `HOSTTOOLS_NONFATAL += "getent"` into your local.conf file.
+
+### Conan
+
+sdbus-c++ recipe is available in ConanCenter repository as [`sdbus-cpp`](https://conan.io/center/sdbus-cpp).
+
+### Buildroot
+
+There is the Buildroot package [`sdbus-cpp`](https://git.buildroot.net/buildroot/tree/package/sdbus-cpp?h=2022.02) to build sdbus-c++ library itself without a code generation tool.
+
+Contributors willing to help with bringing sdbus-c++ to other popular package systems are welcome.
+
+Verifying sdbus-c++
+-------------------
+
+You can build and run sdbus-c++ unit and integration tests to verify sdbus-c++ build:
+
+```
+$ cd build
+$ cmake .. -DBUILD_TESTS=ON
+$ sudo cp ../tests/integrationtests/files/org.sdbuscpp.integrationtests.conf /etc/dbus-1/system.d/
+$ cmake --build . --target test
+```
 
 Header files and namespaces
 ---------------------------
@@ -143,7 +172,7 @@ The following diagram illustrates the major entities in sdbus-c++.
 
 ![class](sdbus-c++-class-diagram.png)
 
-`IConnection` represents the concept of a D-Bus connection. You can connect to either the system bus or a session bus. Services can assign unique service names to those connections. A processing loop should be run on the connection.
+`IConnection` represents the concept of a D-Bus connection. You can connect to either the system bus or a session bus. Services can assign unique service names to those connections. An I/O event loop should be run on the bus connection.
 
 `IObject` represents the concept of an object that exposes its methods, signals and properties. Its responsibilities are:
 
@@ -197,6 +226,8 @@ Let's have an object `/org/sdbuscpp/concatenator` that implements the `org.sdbus
 
 In the following sections, we will elaborate on the ways of implementing such an object on both the server and the client side.
 
+> **Before running Concatenator example in your system:** In order for your service to be allowed to provide a D-Bus API on system bus, a D-Bus security policy file has to be put in place for that service. Otherwise the service will fail to start (you'll get `[org.freedesktop.DBus.Error.AccessDenied] Failed to request bus name (Permission denied)`, for example). To make the Concatenator example work in your system, [look in this section of systemd configuration](systemd-dbus-config.md#dbus-configuration) for how to name the file, where to place it, how to populate it. For further information, consult [dbus-daemon documentation](https://dbus.freedesktop.org/doc/dbus-daemon.1.html), sections *INTEGRATING SYSTEM SERVICES* and *CONFIGURATION FILE*. As an example used for sdbus-c++ integration tests, you may look at the [policy file for sdbus-c++ integration tests](/tests/integrationtests/files/org.sdbuscpp.integrationtests.conf).
+
 Implementing the Concatenator example using basic sdbus-c++ API layer
 ---------------------------------------------------------------------
 
@@ -215,7 +246,7 @@ This is how a simple Concatenator service implemented upon the basic sdbus-c++ A
 #include <vector>
 #include <string>
 
-// Yeah, global variable is ugly, but this is just an example and we want to access 
+// Yeah, global variable is ugly, but this is just an example and we want to access
 // the concatenator instance from within the concatenate method handler to be able
 // to emit signals.
 sdbus::IObject* g_concatenator{};
@@ -225,26 +256,26 @@ void concatenate(sdbus::MethodCall call)
     // Deserialize the collection of numbers from the message
     std::vector<int> numbers;
     call >> numbers;
-    
+
     // Deserialize separator from the message
     std::string separator;
     call >> separator;
-    
+
     // Return error if there are no numbers in the collection
     if (numbers.empty())
         throw sdbus::Error("org.sdbuscpp.Concatenator.Error", "No numbers provided");
-    
+
     std::string result;
     for (auto number : numbers)
     {
         result += (result.empty() ? std::string() : separator) + std::to_string(number);
     }
-    
+
     // Serialize resulting string to the reply and send the reply to the caller
     auto reply = call.createReply();
     reply << result;
     reply.send();
-    
+
     // Emit 'concatenated' signal
     const char* interfaceName = "org.sdbuscpp.Concatenator";
     auto signal = g_concatenator->createSignal(interfaceName, "concatenated");
@@ -261,17 +292,17 @@ int main(int argc, char *argv[])
     // Create concatenator D-Bus object.
     const char* objectPath = "/org/sdbuscpp/concatenator";
     auto concatenator = sdbus::createObject(*connection, objectPath);
-    
+
     g_concatenator = concatenator.get();
-    
+
     // Register D-Bus methods and signals on the concatenator object, and exports the object.
     const char* interfaceName = "org.sdbuscpp.Concatenator";
     concatenator->registerMethod(interfaceName, "concatenate", "ais", "s", &concatenate);
     concatenator->registerSignal(interfaceName, "concatenated", "s");
     concatenator->finishRegistration();
 
-    // Run the loop on the connection.
-    connection->enterProcessingLoop();
+    // Run the I/O event loop on the bus connection.
+    connection->enterEventLoop();
 }
 ```
 
@@ -294,7 +325,7 @@ void onConcatenated(sdbus::Signal& signal)
 {
     std::string concatenatedString;
     signal >> concatenatedString;
-    
+
     std::cout << "Received signal with concatenated string " << concatenatedString << std::endl;
 }
 
@@ -306,15 +337,15 @@ int main(int argc, char *argv[])
     const char* destinationName = "org.sdbuscpp.concatenator";
     const char* objectPath = "/org/sdbuscpp/concatenator";
     auto concatenatorProxy = sdbus::createProxy(destinationName, objectPath);
-    
+
     // Let's subscribe for the 'concatenated' signals
     const char* interfaceName = "org.sdbuscpp.Concatenator";
     concatenatorProxy->registerSignalHandler(interfaceName, "concatenated", &onConcatenated);
     concatenatorProxy->finishRegistration();
-    
+
     std::vector<int> numbers = {1, 2, 3};
     std::string separator = ":";
-    
+
     // Invoke concatenate on given interface of the object
     {
         auto method = concatenatorProxy->createMethodCall(interfaceName, "concatenate");
@@ -324,7 +355,7 @@ int main(int argc, char *argv[])
         reply >> result;
         assert(result == "1:2:3");
     }
-    
+
     // Invoke concatenate again, this time with no numbers and we shall get an error
     {
         auto method = concatenatorProxy->createMethodCall(interfaceName, "concatenate");
@@ -339,10 +370,10 @@ int main(int argc, char *argv[])
             std::cerr << "Got concatenate error " << e.getName() << " with message " << e.getMessage() << std::endl;
         }
     }
-    
+
     // Give sufficient time to receive 'concatenated' signal from the first concatenate invocation
     sleep(1);
-    
+
     return 0;
 }
 ```
@@ -361,27 +392,41 @@ The design of D-Bus connections in sdbus-c++ allows for certain flexibility and
 
 How shall we use connections in relation to D-Bus objects and object proxies?
 
-A D-Bus connection is represented by a `IConnection` instance. Each connection needs an event loop being run upon it. So it needs a thread handling the event loop. This thread serves all incoming and outgoing messages and all communication towards D-Bus daemon.
+A D-Bus connection is represented by a `IConnection` instance. Each connection needs an event loop being run upon it. So it needs a thread handling the event loop. This thread serves all incoming and outgoing messages and all communication towards D-Bus daemon. One process can have one but also multiple D-Bus connections (we just have to make certain that the connections with assigned bus names don't share a common name; the name must be unique).
 
-One process can have multiple D-Bus connections, with assigned unique bus names or without, as long as those with assigned bus names do not share a common bus name.
+A typical use case for most services is **one** D-Bus connection in the application. The application runs event loop on that connection. When creating objects or proxies, the application provides reference of that connection to those objects and proxies. This means all these objects and proxies share the same connection. This is nicely scalable, because with whatever number of objects or proxies, there is only one connection and one event loop thread. Yet, services that provide objects at various bus names have to create and maintain multiple D-Bus connections, each with the unique bus name.
 
-A D-Bus connection can be created for and used exclusively by one D-Bus object (represented by one `IObject` instance) or one D-Bus proxy (represented by one `IProxy` instance), but can very well be used by and shared across multiple objects, multiple proxies or even both multiple objects and proxies at the same time. When shared, one must bear in mind that the access to the connection is mutually exclusive and is serialized. This means, for example, that if an object's callback is going to be invoked for an incoming remote method call and in another thread we use a proxy to call remote method in another process, the threads are contending and only one can go on while the other must wait and can only proceed after the first one has finished, because both are using a shared resource -- the connection.
+The connection is thread-safe and objects and proxies can invoke operations on it from multiple threads simultaneously, but the operations are serialized. This means, for example, that if an object's callback for an incoming remote method call is going to be invoked in an event loop thread, and in another thread we use a proxy to call remote method in another process, the threads are contending and only one can go on while the other must wait and can only proceed after the first one has finished, because both are using a shared resource -- the connection.
 
-The former case (1:1) is one extreme; it's usually simple, has zero resource contention, but hurts scalability (for example, 50 proxies in our program need 50 D-Bus connections and 50 event loop threads upon them). The latter case (1:N) is the other extreme -- all D-Bus objects and proxies share one single connection. This is the most scalable solution (since, for example, 5 or 200 objects/proxies use always one single connection), but may increase contention and hurt concurrency (since only one of all those objects/proxies can work with the connection at a time). And then there are limitless options between the two (for example, we can use one connection for all objects, and another connection for all proxies in our service...). sdbus-c++ gives its users freedom to choose whatever approach is more suitable to them in their application at fine granularity.
+We should bear that in mind when designing more complex, multi-threaded services with high parallelism. If we have undesired contention on a connection, creating a specific, dedicated connection for a hot spot helps to increase concurrency. sdbus-c++ provides us freedom to create as many connections as we want and assign objects and proxies to those connections at our will. We, as application developers, choose whatever approach is more suitable to us at quite a fine granularity.
 
-How can we use connections from the server and the client perspective?
+So, more technically, how can we use connections from the server and the client perspective?
 
-* On the *server* side, we generally need to create D-Bus objects and publish their APIs. For that we first need a connection with a unique bus name. We need to create the D-Bus connection manually ourselves, request bus name on it, and manually launch its event loop (in a blocking way, through `enterProcessingLoop()`, or non-blocking async way, through `enterProcessingLoopAsync()`). At any time before or after running the event loop on the connection, we can create and "hook", as well as remove, objects and proxies upon that connection.
+#### Using D-Bus connections on the server side
 
-* On the *client* side, for our D-Bus object proxies, we have more options (corresponding to three overloads of the `createProxy()` factory):
+On the **server** side, we generally need to create D-Bus objects and publish their APIs. For that we first need a connection with a unique bus name. We need to create the D-Bus connection manually ourselves, request bus name on it, and manually launch its event loop:
 
-    * We don't bother about any connection when creating a proxy. For each proxy instance sdbus-c++ also creates an internal connection instance to be used just by this proxy, and it will be a *system bus* connection. Additionally, an event loop thread for that connection is created and run internally.
+  * either in a blocking way, through `enterEventLoop()`,
+  * or in a non-blocking async way, through `enterEventLoopAsync()`,
+  * or, when we have our own implementation of an event loop (e.g. we are using sd-event event loop), we can ask the connection for its underlying fd, I/O events and timeouts through `getEventLoopPollData()` and use that data in our event loop mechanism.
 
-      This hurts scalability (see discussion above), but our code is simpler, and since each proxy has its own connection, there is zero contention.
+Of course, at any time before or after running the event loop on the connection, we can create and "hook", as well as remove, objects and proxies upon that connection.
 
-    * We create a connection explicitly by ourselves and `std::move` it to the proxy object factory. The proxy becomes an owner of this connection, and will run the event loop on that connection. This is the same as in the above bullet point, but with a flexibility that we can choose the bus type (system, session bus).
+#### Using D-Bus connections on the client side
 
-    * We are always full owners of the connection. We create the connection, and a proxy only takes and keeps a reference to it. We take care of the event loop upon that connection (and we must ensure the connection exists as long as all its users exist).
+On the **client** side we have more options when creating D-Bus proxies. That corresponds to three overloads of the `createProxy()` factory:
+
+  * In case we (the application) already maintain a D-Bus connection, e.g. because we a D-Bus service anyway, the simple and typical approach is to create proxy upon that connection. The proxy will share the connection with others. So we pass connection reference to proxy factory. With this approach we must of course ensure that the connection exists as long as the proxy exists.
+
+  * Or -- and this is typical when we have a simple D-Bus client application -- we have another option: we let proxy maintain its own connection (and an associated thread):
+
+    * We either create the connection ourselves and `std::move` it to the proxy object factory. The proxy becomes an owner of this connection, and will run the event loop on that connection. This had the advantage that we may choose the type of connection (system, session, remote).
+
+    * Or we don't bother about any connection at all when creating a proxy (the factory overload with no connection parameter). Under the hood, the proxy creates its own *system bus* connection, creates a separate thread and runs an event loop in it. This is **the simplest approach** for non-complex D-Bus clients. For more complex ones, with big number of proxies, this hurts scalability but may improve concurrency (see discussion higher above), so we should make a conscious choice.
+
+#### Stopping I/O event loops graciously
+
+A connection with an asynchronous event loop (i.e. one initiated through `enterEventLoopAsync()`) will stop and join its event loop thread automatically in its destructor. An event loop that blocks in the synchronous `enterEventLoop()` call can be unblocked through `leaveEventLoop()` call on the respective bus connection issued from a different thread or from an OS signal handler.
 
 Implementing the Concatenator example using convenience sdbus-c++ API layer
 ---------------------------------------------------------------------------
@@ -393,11 +438,11 @@ The convenience API layer abstracts the concept of underlying D-Bus messages awa
 Thus, in the end of the day, the code written using the convenience API is:
 
   - more expressive,
-  - closer to the abstraction level of the problem being solved,
-  - shorter,
+  - at a higher level of abstraction (closer to the abstraction level of the problem being solved),
+  - significantly shorter,
   - almost as fast as one written using the basic API layer.
 
-The code written using this layer expresses *what* it does, rather then *how*. Let's look at code samples.
+The code written using this layer expresses in a declarative way *what* it does, rather than *how*. Let's look at code samples.
 
 ### Server side
 
@@ -406,30 +451,6 @@ The code written using this layer expresses *what* it does, rather then *how*. L
 #include <vector>
 #include <string>
 
-// Yeah, global variable is ugly, but this is just an example and we want to access 
-// the concatenator instance from within the concatenate method handler to be able
-// to emit signals.
-sdbus::IObject* g_concatenator{};
-
-std::string concatenate(const std::vector<int> numbers, const std::string& separator)
-{
-    // Return error if there are no numbers in the collection
-    if (numbers.empty())
-        throw sdbus::Error("org.sdbuscpp.Concatenator.Error", "No numbers provided");
-    
-    std::string result;
-    for (auto number : numbers)
-    {
-        result += (result.empty() ? std::string() : separator) + std::to_string(number);
-    }
-    
-    // Emit 'concatenated' signal
-    const char* interfaceName = "org.sdbuscpp.Concatenator";
-    g_concatenator->emitSignal("concatenated").onInterface(interfaceName).withArguments(result);
-    
-    return result;
-}
-
 int main(int argc, char *argv[])
 {
     // Create D-Bus connection to the system bus and requests name on it.
@@ -440,16 +461,33 @@ int main(int argc, char *argv[])
     const char* objectPath = "/org/sdbuscpp/concatenator";
     auto concatenator = sdbus::createObject(*connection, objectPath);
     
-    g_concatenator = concatenator.get();
-    
+    auto concatenate = [&concatenator](const std::vector<int> numbers, const std::string& separator)
+    {
+        // Return error if there are no numbers in the collection
+        if (numbers.empty())
+            throw sdbus::Error("org.sdbuscpp.Concatenator.Error", "No numbers provided");
+
+        std::string result;
+        for (auto number : numbers)
+        {
+            result += (result.empty() ? std::string() : separator) + std::to_string(number);
+        }
+
+        // Emit 'concatenated' signal
+        const char* interfaceName = "org.sdbuscpp.Concatenator";
+        concatenator->emitSignal("concatenated").onInterface(interfaceName).withArguments(result);
+
+        return result;
+    };
+
     // Register D-Bus methods and signals on the concatenator object, and exports the object.
     const char* interfaceName = "org.sdbuscpp.Concatenator";
-    concatenator->registerMethod("concatenate").onInterface(interfaceName).implementedAs(&concatenate);
+    concatenator->registerMethod("concatenate").onInterface(interfaceName).implementedAs(std::move(concatenate));
     concatenator->registerSignal("concatenated").onInterface(interfaceName).withParameters<std::string>();
     concatenator->finishRegistration();
 
     // Run the loop on the connection.
-    connection->enterProcessingLoop();
+    connection->enterEventLoop();
 }
 ```
 
@@ -473,22 +511,22 @@ int main(int argc, char *argv[])
     const char* destinationName = "org.sdbuscpp.concatenator";
     const char* objectPath = "/org/sdbuscpp/concatenator";
     auto concatenatorProxy = sdbus::createProxy(destinationName, objectPath);
-    
+
     // Let's subscribe for the 'concatenated' signals
     const char* interfaceName = "org.sdbuscpp.Concatenator";
     concatenatorProxy->uponSignal("concatenated").onInterface(interfaceName).call([](const std::string& str){ onConcatenated(str); });
     concatenatorProxy->finishRegistration();
-    
+
     std::vector<int> numbers = {1, 2, 3};
     std::string separator = ":";
-    
+
     // Invoke concatenate on given interface of the object
     {
         std::string concatenatedString;
         concatenatorProxy->callMethod("concatenate").onInterface(interfaceName).withArguments(numbers, separator).storeResultsTo(concatenatedString);
         assert(concatenatedString == "1:2:3");
     }
-    
+
     // Invoke concatenate again, this time with no numbers and we shall get an error
     {
         try
@@ -501,10 +539,10 @@ int main(int argc, char *argv[])
             std::cerr << "Got concatenate error " << e.getName() << " with message " << e.getMessage() << std::endl;
         }
     }
-    
+
     // Give sufficient time to receive 'concatenated' signal from the first concatenate invocation
     sleep(1);
-    
+
     return 0;
 }
 ```
@@ -513,10 +551,55 @@ When registering methods, calling methods or emitting signals, multiple lines of
 
 sdbus-c++ users shall prefer the convenience API to the lower level, basic API. When feasible, using generated adaptor and proxy stubs is even better. These stubs provide yet another, higher API level built on top of the convenience API. They are described in the following section.
 
+> **_Note_:** By default, signal callback handlers are not invoked (i.e., the signal is silently dropped) if there is a signal signature mismatch. If clients want to be informed of such situations, they can prepend `const sdbus::Error*` parameter to their signal callback handler's parameter list. This argument will be `nullptr` in normal cases, and will provide access to the corresponding `sdbus::Error` object in case of deserialization failures. An example of a handler with the signature (`int`) different from the real signal contents (`string`):
+> ```c++
+>     void onConcatenated(const sdbus::Error* e, int wrongParameter)
+>     {
+>         assert(e);
+>         assert(e->getMessage() == "Failed to deserialize a int32 value");
+>     }
+> ```
+
+> **_Tip_:** When registering a D-Bus object, we can additionally provide names of input and output parameters of its methods and names of parameters of its signals. When the object is introspected, these names are listed in the resulting introspection XML, which improves the description of object's interfaces:
+> ```c++
+>    concatenator->registerMethod("concatenate")
+>                 .onInterface(interfaceName)
+>                 .withInputParamNames("numbers", "separator")
+>                 .withOutputParamNames("concatenatedString")
+>                 .implementedAs(&concatenate);
+>    concatenator->registerSignal("concatenated")
+>                 .onInterface(interfaceName)
+>                 .withParameters<std::string>("concatenatedString");
+> ```
+
+### Accessing a corresponding D-Bus message
+
+The convenience API hides away the level of D-Bus messages. But the messages carry with them additional information that may need in some implementations. For example, a name of a method call sender; or info on credentials. Is there a way to access a corresponding D-Bus message in a high-level callback handler?
+
+Yes, there is -- we can access the corresponding D-Bus message in:
+
+* method implementation callback handlers (server side),
+* property set implementation callback handlers (server side),
+* signal callback handlers (client side).
+
+Both `IObject` and `IProxy` provide the `getCurrentlyProcessedMessage()` method. This method is meant to be called from within a callback handler. It returns a pointer to the corresponding D-Bus message that caused invocation of the handler. The pointer is only valid (dereferencable) as long as the flow of execution does not leave the callback handler. When called from other contexts/threads, the pointer may be both zero or non-zero, and its dereferencing is undefined behavior.
+
+An excerpt of the above example of concatenator modified to print out a name of the sender of method call:
+
+```c++
+    auto concatenate = [&concatenator](const std::vector<int> numbers, const std::string& separator)
+    {
+        const auto* methodCallMsg = concatenator->getCurrentlyProcessedMessage();
+        std::cout << "Sender of this method call: " << methodCallMsg.getSender() << std::endl;
+
+        /*...*/
+    };
+```
+
 Implementing the Concatenator example using sdbus-c++-generated stubs
 ---------------------------------------------------------------------
 
-sdbus-c++ ships with the native stub generator tool called `sdbus-c++-xml2cpp`. The tool is very similar to `dbusxx-xml2cpp` tool that comes with the dbus-c++ project.
+sdbus-c++ ships with the native stub generator tool called `sdbus-c++-xml2cpp`. The tool is very similar to `dbusxx-xml2cpp` tool that comes with the dbus-c++ library.
 
 The generator tool takes D-Bus XML IDL description of D-Bus interfaces on its input, and can be instructed to generate one or both of these: an adaptor header file for use on the server side, and a proxy header file for use on the client side. Like this:
 
@@ -577,8 +660,8 @@ protected:
     Concatenator_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("concatenate").onInterface(INTERFACE_NAME).implementedAs([this](const std::vector<int32_t>& numbers, const std::string& separator){ return this->concatenate(numbers, separator); });
-        object_.registerSignal("concatenated").onInterface(INTERFACE_NAME).withParameters<std::string>();
+        object_.registerMethod("concatenate").onInterface(INTERFACE_NAME).withInputParamNames("numbers", "separator").withOutputParamNames("concatenatedString").implementedAs([this](const std::vector<int32_t>& numbers, const std::string& separator){ return this->concatenate(numbers, separator); });
+        object_.registerSignal("concatenated").onInterface(INTERFACE_NAME).withParameters<std::string>("concatenatedString");
     }
 
     ~Concatenator_adaptor() = default;
@@ -675,7 +758,7 @@ class Concatenator : public sdbus::AdaptorInterfaces<org::sdbuscpp::Concatenator
 {
 public:
     Concatenator(sdbus::IConnection& connection, std::string objectPath)
-        : sdbus::AdaptorInterfaces(connection, std::move(objectPath))
+        : AdaptorInterfaces(connection, std::move(objectPath))
     {
         registerAdaptor();
     }
@@ -691,23 +774,25 @@ protected:
         // Return error if there are no numbers in the collection
         if (numbers.empty())
             throw sdbus::Error("org.sdbuscpp.Concatenator.Error", "No numbers provided");
-        
+
         // Concatenate the numbers
         std::string result;
         for (auto number : numbers)
         {
             result += (result.empty() ? std::string() : separator) + std::to_string(number);
         }
-        
+
         // Emit the 'concatenated' signal with the resulting string
         emitConcatenated(result);
-        
+
         // Return the resulting string
         return result;
     }
 };
 ```
 
+> **_Tip_:** By inheriting from `sdbus::AdaptorInterfaces`, we get access to the protected `getObject()` method. We can call this method inside our adaptor implementation class to access the underlying `IObject` object.
+
 That's it. We now have an implementation of a D-Bus object implementing `org.sdbuscpp.Concatenator` interface. Let's now create a service publishing the object.
 
 ```cpp
@@ -724,7 +809,7 @@ int main(int argc, char *argv[])
     Concatenator concatenator(*connection, objectPath);
 
     // Run the loop on the connection.
-    connection->enterProcessingLoop();
+    connection->enterEventLoop();
 }
 ```
 
@@ -752,12 +837,12 @@ class ConcatenatorProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::Concatena
 {
 public:
     ConcatenatorProxy(std::string destination, std::string objectPath)
-        : sdbus::ProxyInterfaces(std::move(destination), std::move(objectPath))
+        : ProxyInterfaces(std::move(destination), std::move(objectPath))
     {
         registerProxy();
     }
 
-    ~Concatenator()
+    ~ConcatenatorProxy()
     {
         unregisterProxy();
     }
@@ -770,6 +855,8 @@ protected:
 };
 ```
 
+> **_Tip_:** By inheriting from `sdbus::ProxyInterfaces`, we get access to the protected `getProxy()` method. We can call this method inside our proxy implementation class to access the underlying `IProxy` object.
+
 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 by all 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::createProxy` overloads, as they are actually implemented on top of them. See [Proxy and D-Bus connection](#Proxy-and-D-Bus-connection) for more info. We can even create a `IProxy` instance on our own, and inject it into our proxy class -- there is a constructor overload for it in `ProxyInterfaces`. This can help if we need to provide mocked implementations in our unit tests.
@@ -789,11 +876,11 @@ int main(int argc, char *argv[])
 
     std::vector<int> numbers = {1, 2, 3};
     std::string separator = ":";
-    
+
     // Invoke concatenate with some numbers
     auto concatenatedString = concatenatorProxy.concatenate(numbers, separator);
     assert(concatenatedString == "1:2:3");
-    
+
     // Invoke concatenate again, this time with no numbers and we shall get an error
     try
     {
@@ -804,14 +891,35 @@ int main(int argc, char *argv[])
     {
         std::cerr << "Got concatenate error " << e.getName() << " with message " << e.getMessage() << std::endl;
     }
-    
+
     // Give sufficient time to receive 'concatenated' signal from the first concatenate invocation
     sleep(1);
-    
+
     return 0;
 }
 ```
 
+### Accessing a corresponding D-Bus message
+
+Simply combine `getObject()`/`getProxy()` and `getCurrentlyProcessedMessage()` methods. Both were already discussed above. An example:
+
+```c++
+class Concatenator : public sdbus::AdaptorInterfaces</*...*/>
+{
+public:
+    /*...*/
+
+protected:
+    std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator) override
+    {
+        const auto* methodCallMsg = getObject().getCurrentlyProcessedMessage();
+        std::cout << "Sender of this method call: " << methodCallMsg.getSender() << std::endl;
+
+        /*...*/
+    }
+};
+```
+
 Asynchronous server-side methods
 --------------------------------
 
@@ -827,11 +935,11 @@ void concatenate(sdbus::MethodCall call)
     // Deserialize the collection of numbers from the message
     std::vector<int> numbers;
     call >> numbers;
-    
+
     // Deserialize separator from the message
     std::string separator;
     call >> separator;
-    
+
     // Launch a thread for async execution...
     std::thread([numbers = std::move(numbers), separator = std::move(separator), call = std::move(call)]()
     {
@@ -843,18 +951,18 @@ void concatenate(sdbus::MethodCall call)
             reply.send();
             return;
         }
-        
+
         std::string result;
         for (auto number : numbers)
         {
             result += (result.empty() ? std::string() : separator) + std::to_string(number);
         }
-        
+
         // Let's send the reply message back to the client
         auto reply = call.createReply();
         reply << result;
         reply.send();
-        
+
         // Emit 'concatenated' signal (creating and emitting signals is thread-safe)
         const char* interfaceName = "org.sdbuscpp.Concatenator";
         auto signal = g_concatenator->createSignal(interfaceName, "concatenated");
@@ -892,29 +1000,29 @@ void concatenate(sdbus::Result<std::string>&& result, std::vector<int32_t> numbe
             methodResult.returnError({"org.sdbuscpp.Concatenator.Error", "No numbers provided"});
             return;
         }
-        
+
         std::string result;
         for (auto number : numbers)
         {
             result += (result.empty() ? std::string() : separator) + std::to_string(number);
         }
-        
+
         // Let's send the reply message back to the client
-        methodResult.returnReply(result);
-        
+        methodResult.returnResults(result);
+
         // Emit the 'concatenated' signal with the resulting string
         this->emitConcatenated(result);
     }).detach();
 }
 ```
 
-The `Result` is a convenience class that represents a future method result, and it is where we write the results (`returnReply()`) or an error (`returnError()`) which we want to send back to the client.
+The `Result` is a convenience class that represents a future method result, and it is where we write the results (`returnResults()`) or an error (`returnError()`) which we want to send back to the client.
 
 Registraion (`implementedAs()`) doesn't change. Nothing else needs to change.
 
 ### Marking server-side async methods in the IDL
 
-sdbus-c++ stub generator can generate stub code for server-side async methods. We just need to annotate the method with the `annotate` element having the "org.freedesktop.DBus.Method.Async" name. The element value must be either "server" (async method on server-side only) or "clientserver" (async method on both client- and server-side):
+sdbus-c++ stub generator can generate stub code for server-side async methods. We just need to annotate the method with `org.freedesktop.DBus.Method.Async`. The annotation element value must be either `server` (async method on server-side only) or `clientserver` (async method on both client- and server-side):
 
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
@@ -949,7 +1057,7 @@ Considering the Concatenator example based on lower-level API, if we wanted to c
 int main(int argc, char *argv[])
 {
     /* ...  */
-    
+
     auto callback = [](MethodReply& reply, const sdbus::Error* error)
     {
         if (error == nullptr) // No error
@@ -971,7 +1079,7 @@ int main(int argc, char *argv[])
         concatenatorProxy->callMethod(method, callback);
         // When the reply comes, we shall get "Got concatenate result 1:2:3" on the standard output
     }
-    
+
     // Invoke concatenate again, this time with no numbers and we shall get an error
     {
         auto method = concatenatorProxy->createMethodCall(interfaceName, "concatenate");
@@ -996,7 +1104,7 @@ On the convenience API level, the call statement starts with `callMethodAsync()`
 int main(int argc, char *argv[])
 {
     /* ...  */
-    
+
     auto callback = [](const sdbus::Error* error, const std::string& concatenatedString)
     {
         if (error == nullptr) // No error
@@ -1023,11 +1131,11 @@ int main(int argc, char *argv[])
 }
 ```
 
-When the `Error` pointer is zero, it means that no D-Bus error occurred while making the call, and subsequent arguments are valid D-Bus method return values. Non-zero `Error` pointer, however, points to the valid `Error` instance, meaning that an error occurred during the call (and subsequent arguments are simply default-constructed). Error name and message can then be read out by the client from `Error` instance. 
+When the `Error` pointer is zero, it means that no D-Bus error occurred while making the call, and subsequent arguments are valid D-Bus method return values. Non-zero `Error` pointer, however, points to the valid `Error` instance, meaning that an error occurred during the call (and subsequent arguments are simply default-constructed). Error name and message can then be read out by the client from `Error` instance.
 
 ### Marking client-side async methods in the IDL
 
-sdbus-c++ stub generator can generate stub code for client-side async methods. We just need to annotate the method with the `annotate` element having the "org.freedesktop.DBus.Method.Async" name. The element value must be either "client" (async on the client-side only) or "clientserver" (async method on both client- and server-side):
+sdbus-c++ stub generator can generate stub code for client-side async methods. We just need to annotate the method with `org.freedesktop.DBus.Method.Async`. The annotation element value must be either `client` (async on the client-side only) or `clientserver` (async method on both client- and server-side):
 
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
@@ -1047,18 +1155,39 @@ sdbus-c++ stub generator can generate stub code for client-side async methods. W
 </node>
 ```
 
-For each client-side async method, a corresponding `on<MethodName>Reply` pure virtual function, where <MethodName> is capitalized D-Bus method name, is generated in the generated proxy class. This function is the callback invoked when the D-Bus method reply arrives, and must be provided a body by overriding it in the implementation class.
-    
+For each client-side async method, a corresponding `on<MethodName>Reply` pure virtual function, where `<MethodName>` is the capitalized D-Bus method name, is generated in the generated proxy class. This function is the callback invoked when the D-Bus method reply arrives, and must be provided a body by overriding it in the implementation class.
+
 So in the specific example above, the stub generator will generate a `Concatenator_proxy` class similar to one shown in a [dedicated section above](#concatenator-client-glueh), with the difference that it will also generate an additional `virtual void onConcatenateReply(const sdbus::Error* error, const std::string& concatenatedString);` method, which we shall override in derived `ConcatenatorProxy`.
 
 For a real example of a client-side asynchronous D-Bus method, please look at sdbus-c++ [stress tests](/tests/stresstests).
 
+## Method call timeout
+
+Annotate the element with `org.freedesktop.DBus.Method.Timeout` in order to specify the timeout value for the method call. The value should be a number of microseconds or number with duration literal (`us`/`ms`/`s`/`min`). Optionally combine it with `org.freedesktop.DBus.Method.Async`.
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<node>
+  <interface name="org.bluez.Device1">
+    <method name="Connect">
+      <annotation name="org.freedesktop.DBus.Method.Async" value="client"/>
+      <annotation name="org.freedesktop.DBus.Method.Timeout" value="3000ms"/>
+    </method>
+    <method name="Disconnect">
+      <annotation name="org.freedesktop.DBus.Method.Async" value="client"/>
+      <annotation name="org.freedesktop.DBus.Method.Timeout" value="2000000"/> <!-- 2000000us -->
+    </method>
+  </interface>
+</node>
+
+```
+
 Using D-Bus properties
 ----------------------
 
 Defining and working with D-Bus properties using XML description is quite easy.
 
-### Defining a property in the XML
+### Defining a property in the IDL
 
 A property element has no arg child element. It just has the attributes name, type and access, which are all mandatory. The access attribute allows the values ‘readwrite’, ‘read’, and ‘write’.
 
@@ -1143,12 +1272,19 @@ sdbus-c++ provides support for standard D-Bus interfaces. These are:
 
 The implementation of methods that these interfaces define is provided by the library. `Peer`, `Introspectable` and `Properties` are automatically part of interfaces of every D-Bus object. `ObjectManager` is not automatically present and has to be enabled by the client when using `IObject` API. When using generated `ObjectManager_adaptor`, `ObjectManager` is enabled automatically in its constructor.
 
-Pre-generated `*_proxy` and `*_adaptor` convenience classes for these standard interfaces are located in `sdbus-c++/StandardInterfaces.h`. We add them simply as additional parameters of `sdbus::ProxyInterfaces` or `sdbus::AdaptorInterfaces` class template, and our proxy or adaptor class inherits convenience functions from those interface classes.
+Pre-generated `*_proxy` and `*_adaptor` convenience classes for these standard interfaces are located in `sdbus-c++/StandardInterfaces.h`. To use them, we simply have to add them as additional parameters of `sdbus::ProxyInterfaces` or `sdbus::AdaptorInterfaces` class template, and our proxy or adaptor class inherits convenience functions from those interface classes.
 
-For example, to conveniently emit a `PropertyChanged` signal under `org.freedesktop.DBus.Properties` interface, we just issue `emitPropertiesChangedSignal` function of our adaptor object.
+For example, for our `Concatenator` example above in this tutorial, we may want to conveniently emit a `PropertyChanged` signal under `org.freedesktop.DBus.Properties` interface. First, we must augment our `Concatenator` class to also inherit from `org.freedesktop.DBus.Properties` interface: `class Concatenator : public sdbus::AdaptorInterfaces<org::sdbuscpp::Concatenator_adaptor, sdbus::Properties_adaptor> {...};`, and then we just issue `emitPropertiesChangedSignal` function of our adaptor object.
 
 Note that signals of afore-mentioned standard D-Bus interfaces are not emitted by the library automatically. It's clients who are supposed to emit them.
 
+Working examples of using standard D-Bus interfaces can be found in [sdbus-c++ integration tests](/tests/integrationtests/DBusStandardInterfacesTests.cpp) or the [examples](/examples) directory.
+
+Support for match rules
+-----------------------
+
+`IConnection` class provides `addMatch` method that you can use to install match rules. An associated callback handler will be called upon an incoming message matching given match rule. There is support for both client-owned and floating (library-owned) match rules. Consult `IConnection` header or sdbus-c++ doxygen documentation for more information.
+
 Conclusion
 ----------
 

examples/CMakeLists.txt

@@ -0,0 +1,6 @@
+
+add_executable(obj-manager-server org.freedesktop.DBus.ObjectManager/obj-manager-server.cpp)
+target_link_libraries(obj-manager-server sdbus-c++)
+
+add_executable(obj-manager-client org.freedesktop.DBus.ObjectManager/obj-manager-client.cpp)
+target_link_libraries(obj-manager-client sdbus-c++)

examples/org.freedesktop.DBus.ObjectManager/examplemanager-planet1-client-glue.h

@@ -0,0 +1,50 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__examplemanager_planet1_client_glue_h__proxy__H__
+#define __sdbuscpp__examplemanager_planet1_client_glue_h__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+namespace ExampleManager {
+
+class Planet1_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.ExampleManager.Planet1";
+
+protected:
+    Planet1_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~Planet1_proxy() = default;
+
+public:
+    uint64_t GetPopulation()
+    {
+        uint64_t result;
+        proxy_.callMethod("GetPopulation").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+public:
+    std::string Name()
+    {
+        return proxy_.getProperty("Name").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif

examples/org.freedesktop.DBus.ObjectManager/examplemanager-planet1-server-glue.h

@@ -0,0 +1,44 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__examplemanager_planet1_server_glue_h__adaptor__H__
+#define __sdbuscpp__examplemanager_planet1_server_glue_h__adaptor__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+namespace ExampleManager {
+
+class Planet1_adaptor
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.ExampleManager.Planet1";
+
+protected:
+    Planet1_adaptor(sdbus::IObject& object)
+        : object_(object)
+    {
+        object_.registerMethod("GetPopulation").onInterface(INTERFACE_NAME).withOutputParamNames("population").implementedAs([this](){ return this->GetPopulation(); });
+        object_.registerProperty("Name").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Name(); });
+    }
+
+    ~Planet1_adaptor() = default;
+
+private:
+    virtual uint64_t GetPopulation() = 0;
+
+private:
+    virtual std::string Name() = 0;
+
+private:
+    sdbus::IObject& object_;
+};
+
+}}} // namespaces
+
+#endif

examples/org.freedesktop.DBus.ObjectManager/obj-manager-client.cpp

@@ -0,0 +1,110 @@
+/**
+ * Example of a D-Bus client which implements org.freedesktop.DBus.ObjectManager
+ *
+ * The example uses the generated stub API layer to listen to interfaces added to new objects under
+ * "org.sdbuscpp.examplemanager". If added, we access "org.sdbuscpp.ExampleManager.Planet1" to print
+ * info like this:
+ * /org/sdbuscpp/examplemanager/Planet1/Earth added:	org.sdbuscpp.ExampleManager.Planet1
+ * Earth has a population of 7874965825.
+ *
+ */
+
+#include "examplemanager-planet1-client-glue.h"
+#include <sdbus-c++/sdbus-c++.h>
+#include <iostream>
+#include <thread>
+
+class PlanetProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::ExampleManager::Planet1_proxy >
+{
+public:
+    PlanetProxy(sdbus::IConnection& connection, std::string destination, std::string path)
+    : ProxyInterfaces(connection, std::move(destination), std::move(path))
+    {
+        registerProxy();
+    }
+
+    ~PlanetProxy()
+    {
+        unregisterProxy();
+    }
+};
+
+class ManagerProxy final : public sdbus::ProxyInterfaces< sdbus::ObjectManager_proxy >
+{
+public:
+    ManagerProxy(sdbus::IConnection& connection, const std::string& destination, std::string path)
+    : ProxyInterfaces(connection, destination, std::move(path))
+    , m_connection(connection)
+    , m_destination(destination)
+    {
+        registerProxy();
+    }
+
+    ~ManagerProxy()
+    {
+        unregisterProxy();
+    }
+
+    void handleExistingObjects()
+    {
+        std::map<sdbus::ObjectPath, std::map<std::string, std::map<std::string, sdbus::Variant>>> objectsInterfacesAndProperties;
+        objectsInterfacesAndProperties = GetManagedObjects();
+        for (const auto& [object, interfacesAndProperties] : objectsInterfacesAndProperties) {
+            onInterfacesAdded(object, interfacesAndProperties);
+        }
+    }
+
+private:
+    void onInterfacesAdded( const sdbus::ObjectPath& objectPath
+            , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties) override
+    {
+        std::cout << objectPath << " added:\t";
+        for (const auto& [interface, _] : interfacesAndProperties) {
+            std::cout << interface << " ";
+        }
+        std::cout << std::endl;
+
+        // Parse and print some more info
+        auto planetInterface = interfacesAndProperties.find(org::sdbuscpp::ExampleManager::Planet1_proxy::INTERFACE_NAME);
+        if (planetInterface == interfacesAndProperties.end()) {
+            return;
+        }
+        const auto& properties = planetInterface->second;
+        // get a property which was passed as part of the signal.
+        const auto& name = properties.at("Name").get<std::string>();
+        // or create a proxy instance to the newly added object.
+        PlanetProxy planet(m_connection, m_destination, objectPath);
+        std::cout << name << " has a population of " << planet.GetPopulation() << ".\n" << std::endl;
+    }
+
+    void onInterfacesRemoved( const sdbus::ObjectPath& objectPath
+            , const std::vector<std::string>& interfaces) override
+    {
+        std::cout << objectPath << " removed:\t";
+        for (const auto& interface : interfaces) {
+            std::cout << interface << " ";
+        }
+        std::cout << std::endl;
+    }
+
+    sdbus::IConnection& m_connection;
+    std::string m_destination;
+};
+
+int main()
+{
+    auto connection = sdbus::createSessionBusConnection();
+
+    auto managerProxy = std::make_unique<ManagerProxy>(*connection, "org.sdbuscpp.examplemanager", "/org/sdbuscpp/examplemanager");
+    try {
+        managerProxy->handleExistingObjects();
+    }
+    catch (const sdbus::Error& e) {
+        if (e.getName() == "org.freedesktop.DBus.Error.ServiceUnknown") {
+            std::cout << "Waiting for server to start ..." << std::endl;
+        }
+    }
+
+    connection->enterEventLoop();
+    return 0;
+}

examples/org.freedesktop.DBus.ObjectManager/obj-manager-server.cpp

@@ -0,0 +1,108 @@
+/**
+ * Example of a D-Bus server which implements org.freedesktop.DBus.ObjectManager
+ *
+ * The example uses the generated stub API layer to register an object manager under "org.sdbuscpp.examplemanager"
+ * and add objects underneath which implement "org.sdbuscpp.ExampleManager.Planet1".
+ *
+ * We add and remove objects after a few seconds and print info like this:
+ * Creating PlanetAdaptor in 5 4 3 2 1
+ * Creating PlanetAdaptor in 5 4 3 2 1
+ * Creating PlanetAdaptor in 5 4 3 2 1
+ * Removing PlanetAdaptor in 5 4 3 2 1
+ * Removing PlanetAdaptor in 5 4 3 2 1
+ */
+
+#include "examplemanager-planet1-server-glue.h"
+#include <sdbus-c++/sdbus-c++.h>
+#include <iostream>
+#include <memory>
+#include <thread>
+#include <chrono>
+
+class ManagerAdaptor : public sdbus::AdaptorInterfaces< sdbus::ObjectManager_adaptor >
+{
+public:
+    ManagerAdaptor(sdbus::IConnection& connection, std::string path)
+    : AdaptorInterfaces(connection, std::move(path))
+    {
+        registerAdaptor();
+    }
+
+    ~ManagerAdaptor()
+    {
+        unregisterAdaptor();
+    }
+};
+
+class PlanetAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::ExampleManager::Planet1_adaptor,
+                                                sdbus::ManagedObject_adaptor,
+                                                sdbus::Properties_adaptor >
+{
+public:
+    PlanetAdaptor(sdbus::IConnection& connection, std::string path, std::string name, uint64_t poulation)
+    : AdaptorInterfaces(connection, std::move(path))
+    , m_name(std::move(name))
+    , m_population(poulation)
+    {
+        registerAdaptor();
+        emitInterfacesAddedSignal({org::sdbuscpp::ExampleManager::Planet1_adaptor::INTERFACE_NAME});
+    }
+
+    ~PlanetAdaptor()
+    {
+        emitInterfacesRemovedSignal({org::sdbuscpp::ExampleManager::Planet1_adaptor::INTERFACE_NAME});
+        unregisterAdaptor();
+    }
+
+    uint64_t GetPopulation() override
+    {
+        return m_population;
+    }
+
+    std::string Name() override
+    {
+        return m_name;
+    }
+
+private:
+    std::string m_name;
+    uint64_t m_population;
+};
+
+void printCountDown(const std::string& message, int seconds)
+{
+    std::cout << message << std::flush;
+    for (int i = seconds; i > 0; i--) {
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        std::cout << i << " " << std::flush;
+    }
+    std::cout << std::endl;
+}
+
+int main()
+{
+    auto connection = sdbus::createSessionBusConnection();
+    connection->requestName("org.sdbuscpp.examplemanager");
+    connection->enterEventLoopAsync();
+
+    auto manager = std::make_unique<ManagerAdaptor>(*connection, "/org/sdbuscpp/examplemanager");
+    while (true)
+    {
+        printCountDown("Creating PlanetAdaptor in ", 5);
+        auto earth = std::make_unique<PlanetAdaptor>(*connection, "/org/sdbuscpp/examplemanager/Planet1/Earth", "Earth", 7'874'965'825);
+        printCountDown("Creating PlanetAdaptor in ", 5);
+        auto trantor = std::make_unique<PlanetAdaptor>(*connection, "/org/sdbuscpp/examplemanager/Planet1/Trantor", "Trantor", 40'000'000'000);
+        printCountDown("Creating PlanetAdaptor in ", 5);
+        auto laconia = std::make_unique<PlanetAdaptor>(*connection, "/org/sdbuscpp/examplemanager/Planet1/Laconia", "Laconia", 231'721);
+        printCountDown("Removing PlanetAdaptor in ", 5);
+        earth.reset();
+        printCountDown("Removing PlanetAdaptor in ", 5);
+        trantor.reset();
+        printCountDown("Removing PlanetAdaptor in ", 5);
+        laconia.reset();
+    }
+
+    connection->releaseName("org.sdbuscpp.examplemanager");
+    connection->leaveEventLoop();
+    return 0;
+}

examples/org.freedesktop.DBus.ObjectManager/org.sdbuscpp.ExampleManager.Planet1.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!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.sdbuscpp.ExampleManager.Planet1">
+
+        <!--
+          @brief get the population of this planet
+          @param [out] population of the planet
+        -->
+        <method name="GetPopulation">
+            <arg name="population" type="t" direction="out" />
+        </method>
+
+        <!--
+          @brief This planet's name
+        -->
+        <property name="Name" type="s" access="read"/>
+
+    </interface>
+</node>

include/sdbus-c++/AdaptorInterfaces.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file AdaptorInterfaces.h
  *
@@ -131,8 +131,17 @@ namespace sdbus {
             getObject().unregister();
         }
 
+        /*!
+         * @brief Returns object path of the underlying DBus object
+         */
+        const std::string& getObjectPath() const
+        {
+            return getObject().getObjectPath();
+        }
+
     protected:
         using base_type = AdaptorInterfaces;
+        ~AdaptorInterfaces() = default;
     };
 
 }

include/sdbus-c++/ConvenienceApiClasses.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file ConvenienceApiClasses.h
  *
@@ -31,6 +31,7 @@
 #include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Flags.h>
 #include <string>
+#include <vector>
 #include <type_traits>
 #include <chrono>
 #include <cstdint>
@@ -41,6 +42,7 @@ namespace sdbus {
     class IProxy;
     class Variant;
     class Error;
+    class PendingAsyncCall;
 }
 
 namespace sdbus {
@@ -53,10 +55,11 @@ namespace sdbus {
         ~MethodRegistrator() noexcept(false);
 
         MethodRegistrator& onInterface(std::string interfaceName);
-        template <typename _Function>
-        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>, MethodRegistrator&> implementedAs(_Function&& callback);
+        template <typename _Function> MethodRegistrator& implementedAs(_Function&& callback);
+        MethodRegistrator& withInputParamNames(std::vector<std::string> paramNames);
+        template <typename... _String> MethodRegistrator& withInputParamNames(_String... paramNames);
+        MethodRegistrator& withOutputParamNames(std::vector<std::string> paramNames);
+        template <typename... _String> MethodRegistrator& withOutputParamNames(_String... paramNames);
         MethodRegistrator& markAsDeprecated();
         MethodRegistrator& markAsPrivileged();
         MethodRegistrator& withNoReply();
@@ -66,7 +69,9 @@ namespace sdbus {
         const std::string& methodName_;
         std::string interfaceName_;
         std::string inputSignature_;
+        std::vector<std::string> inputParamNames_;
         std::string outputSignature_;
+        std::vector<std::string> outputParamNames_;
         method_callback methodCallback_;
         Flags flags_;
         int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
@@ -81,6 +86,8 @@ namespace sdbus {
 
         SignalRegistrator& onInterface(std::string interfaceName);
         template <typename... _Args> SignalRegistrator& withParameters();
+        template <typename... _Args> SignalRegistrator& withParameters(std::vector<std::string> paramNames);
+        template <typename... _Args, typename... _String> SignalRegistrator& withParameters(_String... paramNames);
         SignalRegistrator& markAsDeprecated();
 
     private:
@@ -88,6 +95,7 @@ namespace sdbus {
         const std::string& signalName_;
         std::string interfaceName_;
         std::string signalSignature_;
+        std::vector<std::string> paramNames_;
         Flags flags_;
         int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
     };
@@ -186,7 +194,7 @@ namespace sdbus {
         template <typename _Rep, typename _Period>
         AsyncMethodInvoker& withTimeout(const std::chrono::duration<_Rep, _Period>& timeout);
         template <typename... _Args> AsyncMethodInvoker& withArguments(_Args&&... args);
-        template <typename _Function> void uponReplyInvoke(_Function&& callback);
+        template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
 
     private:
         IProxy& proxy_;
@@ -208,6 +216,17 @@ namespace sdbus {
         std::string interfaceName_;
     };
 
+    class SignalUnsubscriber
+    {
+    public:
+        SignalUnsubscriber(IProxy& proxy, const std::string& signalName);
+        void onInterface(std::string interfaceName);
+
+    private:
+        IProxy& proxy_;
+        const std::string& signalName_;
+    };
+
     class PropertyGetter
     {
     public:

include/sdbus-c++/ConvenienceApiClasses.inl

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file ConvenienceApiClasses.inl
  *
@@ -70,7 +70,14 @@ namespace sdbus {
         // Therefore, we can allow registerMethod() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(methodCallback_), flags_);
+        object_.registerMethod( interfaceName_
+                              , std::move(methodName_)
+                              , std::move(inputSignature_)
+                              , std::move(inputParamNames_)
+                              , std::move(outputSignature_)
+                              , std::move(outputParamNames_)
+                              , std::move(methodCallback_)
+                              , std::move(flags_));
     }
 
     inline MethodRegistrator& MethodRegistrator::onInterface(std::string interfaceName)
@@ -81,36 +88,7 @@ namespace sdbus {
     }
 
     template <typename _Function>
-    inline std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> MethodRegistrator::implementedAs(_Function&& callback)
-    {
-        inputSignature_ = signature_of_function_input_arguments<_Function>::str();
-        outputSignature_ = signature_of_function_output_arguments<_Function>::str();
-        methodCallback_ = [callback = std::forward<_Function>(callback)](MethodCall call)
-        {
-            // Create a tuple of callback input arguments' types, which will be used
-            // as a storage for the argument values deserialized from the message.
-            tuple_of_function_input_arg_types_t<_Function> inputArgs;
-
-            // Deserialize input arguments from the message into the tuple
-            call >> inputArgs;
-
-            // Invoke callback with input arguments from the tuple.
-            // For callbacks returning a non-void value, `apply' also returns that value.
-            // For callbacks returning void, `apply' returns an empty tuple.
-            auto ret = sdbus::apply(callback, inputArgs); // We don't yet have C++17's std::apply :-(
-
-            // The return value is stored to the reply message.
-            // In case of void functions, ret is an empty tuple and thus nothing is stored.
-            auto reply = call.createReply();
-            reply << ret;
-            reply.send();
-        };
-
-        return *this;
-    }
-
-    template <typename _Function>
-    inline std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&> MethodRegistrator::implementedAs(_Function&& callback)
+    MethodRegistrator& MethodRegistrator::implementedAs(_Function&& callback)
     {
         inputSignature_ = signature_of_function_input_arguments<_Function>::str();
         outputSignature_ = signature_of_function_output_arguments<_Function>::str();
@@ -123,13 +101,57 @@ namespace sdbus {
             // Deserialize input arguments from the message into the tuple.
             call >> inputArgs;
 
-            // Invoke callback with input arguments from the tuple.
-            sdbus::apply(callback, typename function_traits<_Function>::async_result_t{std::move(call)}, std::move(inputArgs));
+            if constexpr (!is_async_method_v<_Function>)
+            {
+                // Invoke callback with input arguments from the tuple.
+                auto ret = sdbus::apply(callback, inputArgs);
+
+                // Store output arguments to the reply message and send it back.
+                auto reply = call.createReply();
+                reply << ret;
+                reply.send();
+            }
+            else
+            {
+                // Invoke callback with input arguments from the tuple and with result object to be set later
+                using AsyncResult = typename function_traits<_Function>::async_result_t;
+                sdbus::apply(callback, AsyncResult{std::move(call)}, std::move(inputArgs));
+            }
         };
 
         return *this;
     }
 
+    inline MethodRegistrator& MethodRegistrator::withInputParamNames(std::vector<std::string> paramNames)
+    {
+        inputParamNames_ = std::move(paramNames);
+
+        return *this;
+    }
+
+    template <typename... _String>
+    inline MethodRegistrator& MethodRegistrator::withInputParamNames(_String... paramNames)
+    {
+        static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
+
+        return withInputParamNames({paramNames...});
+    }
+
+    inline MethodRegistrator& MethodRegistrator::withOutputParamNames(std::vector<std::string> paramNames)
+    {
+        outputParamNames_ = std::move(paramNames);
+
+        return *this;
+    }
+
+    template <typename... _String>
+    inline MethodRegistrator& MethodRegistrator::withOutputParamNames(_String... paramNames)
+    {
+        static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
+
+        return withOutputParamNames({paramNames...});
+    }
+
     inline MethodRegistrator& MethodRegistrator::markAsDeprecated()
     {
         flags_.set(Flags::DEPRECATED);
@@ -179,7 +201,11 @@ namespace sdbus {
         // Therefore, we can allow registerSignal() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerSignal(interfaceName_, signalName_, signalSignature_, flags_);
+        object_.registerSignal( interfaceName_
+                              , std::move(signalName_)
+                              , std::move(signalSignature_)
+                              , std::move(paramNames_)
+                              , std::move(flags_) );
     }
 
     inline SignalRegistrator& SignalRegistrator::onInterface(std::string interfaceName)
@@ -197,6 +223,23 @@ namespace sdbus {
         return *this;
     }
 
+    template <typename... _Args>
+    inline SignalRegistrator& SignalRegistrator::withParameters(std::vector<std::string> paramNames)
+    {
+        paramNames_ = std::move(paramNames);
+
+        return withParameters<_Args...>();
+    }
+
+    template <typename... _Args, typename... _String>
+    inline SignalRegistrator& SignalRegistrator::withParameters(_String... paramNames)
+    {
+        static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
+        static_assert(sizeof...(_Args) == sizeof...(_String), "Numbers of signal parameters and their names don't match");
+
+        return withParameters<_Args...>({paramNames...});
+    }
+
     inline SignalRegistrator& SignalRegistrator::markAsDeprecated()
     {
         flags_.set(Flags::DEPRECATED);
@@ -533,7 +576,7 @@ namespace sdbus {
     }
 
     template <typename _Function>
-    void AsyncMethodInvoker::uponReplyInvoke(_Function&& callback)
+    PendingAsyncCall AsyncMethodInvoker::uponReplyInvoke(_Function&& callback)
     {
         assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
@@ -545,13 +588,26 @@ namespace sdbus {
 
             // Deserialize input arguments from the message into the tuple (if no error occurred).
             if (error == nullptr)
-                reply >> args;
+            {
+                try
+                {
+                    reply >> args;
+                }
+                catch (const Error& e)
+                {
+                    // Catch message unpack exceptions and pass them to the callback
+                    // in the expected manner to avoid propagating them up the call
+                    // stack to the event loop.
+                    sdbus::apply(callback, &e, args);
+                    return;
+                }
+            }
 
             // Invoke callback with input arguments from the tuple.
-            sdbus::apply(callback, error, args); // TODO: Use std::apply when switching to full C++17 support
+            sdbus::apply(callback, error, args);
         };
 
-        proxy_.callMethod(method_, std::move(asyncReplyHandler), timeout_);
+        return proxy_.callMethod(method_, std::move(asyncReplyHandler), timeout_);
     }
 
     /*** ---------------- ***/
@@ -584,14 +640,52 @@ namespace sdbus {
             // as a storage for the argument values deserialized from the signal message.
             tuple_of_function_input_arg_types_t<_Function> signalArgs;
 
-            // Deserialize input arguments from the signal message into the tuple
-            signal >> signalArgs;
+            // The signal handler can take pure signal parameters only, or an additional `const Error*` as its first
+            // parameter. In the former case, if the deserialization fails (e.g. due to signature mismatch),
+            // the failure is ignored (and signal simply dropped). In the latter case, the deserialization failure
+            // will be communicated as a non-zero Error pointer to the client's signal handler.
+            if constexpr (has_error_param_v<_Function>)
+            {
+                // Deserialize input arguments from the signal message into the tuple
+                try
+                {
+                    signal >> signalArgs;
+                }
+                catch (const sdbus::Error& e)
+                {
+                    // Invoke callback with error argument and input arguments from the tuple.
+                    sdbus::apply(callback, &e, signalArgs);
+                }
 
-            // Invoke callback with input arguments from the tuple.
-            sdbus::apply(callback, signalArgs); // We don't yet have C++17's std::apply :-(
+                // Invoke callback with no error and input arguments from the tuple.
+                sdbus::apply(callback, nullptr, signalArgs);
+            }
+            else
+            {
+                // Deserialize input arguments from the signal message into the tuple
+                signal >> signalArgs;
+
+                // Invoke callback with input arguments from the tuple.
+                sdbus::apply(callback, signalArgs);
+            }
         });
     }
 
+    /*** ------------------ ***/
+    /*** SignalUnsubscriber ***/
+    /*** ------------------ ***/
+
+    inline SignalUnsubscriber::SignalUnsubscriber(IProxy& proxy, const std::string& signalName)
+        : proxy_(proxy)
+        , signalName_(signalName)
+    {
+    }
+
+    inline void SignalUnsubscriber::onInterface(std::string interfaceName)
+    {
+        proxy_.unregisterSignalHandler(interfaceName, signalName_);
+    }
+
     /*** -------------- ***/
     /*** PropertyGetter ***/
     /*** -------------- ***/

include/sdbus-c++/Error.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Error.h
  *
@@ -43,6 +43,11 @@ namespace sdbus {
         : public std::runtime_error
     {
     public:
+        explicit Error(const std::string& name, const char* message = nullptr)
+            : Error(name, std::string(message ? message : ""))
+        {
+        }
+
         Error(const std::string& name, const std::string& message)
             : std::runtime_error("[" + name + "] " + message)
             , name_(name)

include/sdbus-c++/Flags.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Flags.h
  *

include/sdbus-c++/IConnection.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file IConnection.h
  *
@@ -27,10 +27,12 @@
 #ifndef SDBUS_CXX_ICONNECTION_H_
 #define SDBUS_CXX_ICONNECTION_H_
 
+#include <sdbus-c++/TypeTraits.h>
 #include <string>
 #include <memory>
 #include <chrono>
 #include <cstdint>
+#include <optional>
 
 namespace sdbus {
 
@@ -38,7 +40,7 @@ namespace sdbus {
      * @class IConnection
      *
      * An interface to D-Bus bus connection. Incorporates implementation
-     * of both synchronous and asynchronous processing loop.
+     * of both synchronous and asynchronous D-Bus I/O event loop.
      *
      * All methods throw sdbus::Error in case of failure. All methods in
      * this class are thread-aware, but not thread-safe.
@@ -47,11 +49,66 @@ namespace sdbus {
     class IConnection
     {
     public:
+        /*!
+         * Poll Data for external event loop implementations.
+         *
+         * To integrate sdbus with your app's own custom event handling system
+         * you can use this method to query which file descriptors, poll events
+         * and timeouts you should add to your app's poll(2), or select(2)
+         * call in your main event loop.
+         *
+         * If you are unsure what this all means then use
+         * enterEventLoop() or enterEventLoopAsync() instead.
+         *
+         * See: getEventLoopPollData()
+         */
         struct PollData
         {
+            /*!
+             * The read fd to be monitored by the event loop.
+             */
             int fd;
+            /*!
+             * The events to use for poll(2) alongside fd.
+             */
             short int events;
+
+            /*!
+             * Absolute timeout value in micro seconds and based of CLOCK_MONOTONIC.
+             */
             uint64_t timeout_usec;
+
+            /*!
+             * The read fd to be monitored by the event loop.
+             */
+            int event_fd;
+
+            /*!
+             * Get the event poll timeout.
+             *
+             * The timeout is an absolute value based of CLOCK_MONOTONIC.
+             *
+             * @return a duration since the CLOCK_MONOTONIC epoch started.
+             */
+            [[nodiscard]] std::chrono::microseconds getAbsoluteTimeout() const
+            {
+                return std::chrono::microseconds(timeout_usec);
+            }
+
+            /*!
+             * Get the timeout as relative value from now
+             *
+             * @return std::nullopt if the timeout is indefinite. A duration otherwise.
+             */
+            [[nodiscard]] std::optional<std::chrono::microseconds> getRelativeTimeout() const;
+
+            /*!
+             * Get a converted, relative timeout which can be passed as argument 'timeout' to poll(2)
+             *
+             * @return -1 if the timeout is indefinite. 0 if the poll(2) shouldn't block. An integer in milli
+             * seconds otherwise.
+             */
+            [[nodiscard]] int getPollTimeout() const;
         };
 
         virtual ~IConnection() = default;
@@ -82,31 +139,31 @@ namespace sdbus {
         virtual std::string getUniqueName() const = 0;
 
         /*!
-         * @brief Enters the D-Bus processing loop
+         * @brief Enters I/O event loop on this bus connection
          *
          * The incoming D-Bus messages are processed in the loop. The method
-         * blocks indefinitely, until unblocked via leaveProcessingLoop.
+         * blocks indefinitely, until unblocked through leaveEventLoop().
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual void enterProcessingLoop() = 0;
+        virtual void enterEventLoop() = 0;
 
         /*!
-         * @brief Enters the D-Bus processing loop in a separate thread
+         * @brief Enters I/O event loop on this bus connection in a separate thread
          *
-         * The same as enterProcessingLoop, except that it doesn't block
-         * because it runs the loop in a separate thread managed internally.
+         * The same as enterEventLoop, except that it doesn't block
+         * because it runs the loop in a separate, internally managed thread.
          */
-        virtual void enterProcessingLoopAsync() = 0;
+        virtual void enterEventLoopAsync() = 0;
 
         /*!
-         * @brief Leaves the D-Bus processing loop
+         * @brief Leaves the I/O event loop running on this bus connection
          *
-         * Ends the previously started processing loop.
+         * This causes the loop to exit and frees the thread serving the loop
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual void leaveProcessingLoop() = 0;
+        virtual void leaveEventLoop() = 0;
 
         /*!
          * @brief Adds an ObjectManager at the specified D-Bus object path
@@ -115,12 +172,18 @@ namespace sdbus {
          * the connection. This is a convenient way to interrogate a connection
          * to see what objects it has.
          *
+         * This call creates a floating registration. The ObjectManager will
+         * be there for the object path until the connection is destroyed.
+         *
+         * Another, recommended way to add object managers is directly through
+         * IObject API.
+         *
          * @throws sdbus::Error in case of failure
          */
-        virtual void addObjectManager(const std::string& objectPath) = 0;
+        [[deprecated("Use one of other addObjectManager overloads")]] virtual void addObjectManager(const std::string& objectPath) = 0;
 
         /*!
-         * @brief Returns parameters you can pass to poll
+         * @brief Returns fd, I/O events and timeout data you can pass to poll
          *
          * To integrate sdbus with your app's own custom event handling system
          * (without the requirement of an extra thread), you can use this
@@ -130,26 +193,31 @@ namespace sdbus {
          * to process the event. This means that all of sdbus's callbacks will
          * arrive on your app's main event thread (opposed to on a thread created
          * by sdbus-c++). If you are unsure what this all means then use
-         * enterProcessingLoop() or enterProcessingLoopAsync() instead.
+         * enterEventLoop() or enterEventLoopAsync() instead.
          *
          * To integrate sdbus-c++ into a gtk app, pass the file descriptor returned
          * by this method to g_main_context_add_poll.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual PollData getProcessLoopPollData() const = 0;
+        virtual PollData getEventLoopPollData() const = 0;
 
         /*!
          * @brief Process a pending request
          *
+         * @returns true if an event was processed, false if poll should be called
+         *
          * Processes a single dbus event. All of sdbus-c++'s callbacks will be called
          * from within this method. This method should ONLY be used in conjuction
-         * with getProcessLoopPollData(). enterProcessingLoop() and
-         * enterProcessingLoopAsync() will call this method for you, so there is no
-         * need to call it when using these. If you are unsure what this all means then
-         * don't use this method.
+         * with getEventLoopPollData().
+         * This method returns true if an I/O message was processed. This you can try
+         * to call this method again before going to poll on I/O events. The method
+         * returns false if no operations were pending, and the caller should then
+         * poll for I/O events before calling this method again.
+         * enterEventLoop() and enterEventLoopAsync() will call this method for you,
+         * so there is no need to call it when using these. If you are unsure what
+         * this all means then don't use this method.
          *
-         * @returns true if an event was processed
          * @throws sdbus::Error in case of failure
          */
         virtual bool processPendingRequest() = 0;
@@ -184,6 +252,92 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual uint64_t getMethodCallTimeout() const = 0;
+
+        /*!
+         * @brief Adds an ObjectManager at the specified D-Bus object path
+         *
+         * Creates an ObjectManager interface at the specified object path on
+         * the connection. This is a convenient way to interrogate a connection
+         * to see what objects it has.
+         *
+         * This call creates a floating registration. The ObjectManager will
+         * be there for the object path until the connection is destroyed.
+         *
+         * Another, recommended way to add object managers is directly through
+         * IObject API.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void addObjectManager(const std::string& objectPath, floating_slot_t) = 0;
+
+        /*!
+         * @brief Adds a match rule for incoming message dispatching
+         *
+         * @param[in] match Match expression to filter incoming D-Bus message
+         * @param[in] callback Callback handler to be called upon incoming D-Bus message matching the rule
+         * @return RAII-style slot handle representing the ownership of the subscription
+         *
+         * The method installs a match rule for messages received on the specified bus connection.
+         * The syntax of the match rule expression passed in match is described in the D-Bus specification.
+         * The specified handler function callback is called for each incoming message matching the specified
+         * expression. The match is installed synchronously when connected to a bus broker, i.e. the call
+         * sends a control message requested the match to be added to the broker and waits until the broker
+         * confirms the match has been installed successfully.
+         *
+         * Simply let go of the slot instance to uninstall the match rule from the bus connection. The slot
+         * must not outlive the connection for the slot is associated with it.
+         *
+         * For more information, consult `man sd_bus_add_match`.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] virtual Slot addMatch(const std::string& match, message_handler callback) = 0;
+
+        /*!
+         * @brief Adds a floating match rule for incoming message dispatching
+         *
+         * @param[in] match Match expression to filter incoming D-Bus message
+         * @param[in] callback Callback handler to be called upon incoming D-Bus message matching the rule
+         * @param[in] Floating slot tag
+         *
+         * The method installs a floating match rule for messages received on the specified bus connection.
+         * Floating means that the bus connection object owns the match rule, i.e. lifetime of the match rule
+         * is bound to the lifetime of the bus connection.
+         *
+         * Refer to the @c addMatch(const std::string& match, message_handler callback) documentation for more
+         * information.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void addMatch(const std::string& match, message_handler callback, floating_slot_t) = 0;
+
+        /*!
+         * @copydoc IConnection::enterEventLoop()
+         *
+         * @deprecated This function has been replaced by enterEventLoop()
+         */
+        [[deprecated("This function has been replaced by enterEventLoop()")]] void enterProcessingLoop();
+
+        /*!
+         * @copydoc IConnection::enterProcessingLoopAsync()
+         *
+         * @deprecated This function has been replaced by enterEventLoopAsync()
+         */
+        [[deprecated("This function has been replaced by enterEventLoopAsync()")]] void enterProcessingLoopAsync();
+
+        /*!
+         * @copydoc IConnection::leaveProcessingLoop()
+         *
+         * @deprecated This function has been replaced by leaveEventLoop()
+         */
+        [[deprecated("This function has been replaced by leaveEventLoop()")]] void leaveProcessingLoop();
+
+        /*!
+         * @copydoc IConnection::getProcessLoopPollData()
+         *
+         * @deprecated This function has been replaced by getEventLoopPollData()
+         */
+        [[deprecated("This function has been replaced by getEventLoopPollData()")]] PollData getProcessLoopPollData() const;
     };
 
     template <typename _Rep, typename _Period>
@@ -193,62 +347,113 @@ namespace sdbus {
         return setMethodCallTimeout(microsecs.count());
     }
 
+    inline void IConnection::enterProcessingLoop()
+    {
+        enterEventLoop();
+    }
+
+    inline void IConnection::enterProcessingLoopAsync()
+    {
+        enterEventLoopAsync();
+    }
+
+    inline void IConnection::leaveProcessingLoop()
+    {
+        leaveEventLoop();
+    }
+
+    inline IConnection::PollData IConnection::getProcessLoopPollData() const
+    {
+        return getEventLoopPollData();
+    }
+
     /*!
-     * @brief Creates/opens D-Bus system connection
+     * @brief Creates/opens D-Bus system bus connection
      *
      * @return Connection instance
      *
      * @throws sdbus::Error in case of failure
      */
-    std::unique_ptr<sdbus::IConnection> createConnection();
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection();
 
     /*!
-     * @brief Creates/opens D-Bus system connection with a name
+     * @brief Creates/opens D-Bus system bus connection with a name
      *
      * @param[in] name Name to request on the connection after its opening
      * @return Connection instance
      *
      * @throws sdbus::Error in case of failure
      */
-    std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name);
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name);
 
     /*!
-     * @brief Creates/opens D-Bus system connection
+     * @brief Creates/opens D-Bus session bus connection when in a user context, and a system bus connection, otherwise.
      *
      * @return Connection instance
      *
      * @throws sdbus::Error in case of failure
      */
-    std::unique_ptr<sdbus::IConnection> createSystemBusConnection();
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDefaultBusConnection();
 
     /*!
-     * @brief Creates/opens D-Bus system connection with a name
+     * @brief Creates/opens D-Bus session bus connection with a name when in a user context, and a system bus connection with a name, otherwise.
      *
      * @param[in] name Name to request on the connection after its opening
      * @return Connection instance
      *
      * @throws sdbus::Error in case of failure
      */
-    std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name);
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string& name);
 
     /*!
-     * @brief Creates/opens D-Bus session connection
+     * @brief Creates/opens D-Bus system bus connection
      *
      * @return Connection instance
      *
      * @throws sdbus::Error in case of failure
      */
-    std::unique_ptr<sdbus::IConnection> createSessionBusConnection();
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSystemBusConnection();
 
     /*!
-     * @brief Creates/opens D-Bus session connection with a name
+     * @brief Creates/opens D-Bus system bus connection with a name
      *
      * @param[in] name Name to request on the connection after its opening
      * @return Connection instance
      *
      * @throws sdbus::Error in case of failure
      */
-    std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name);
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name);
+
+    /*!
+     * @brief Creates/opens D-Bus session bus connection
+     *
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnection();
+
+    /*!
+     * @brief Creates/opens D-Bus session bus connection with a name
+     *
+     * @param[in] name Name to request on the connection after its opening
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name);
+
+    /*!
+     * @brief Creates/opens D-Bus session bus connection at a custom address
+     *
+     * @param[in] address ";"-separated list of addresses of bus brokers to try to connect
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     *
+     * Consult manual pages for `sd_bus_set_address` of the underlying sd-bus library for more information.
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnectionWithAddress(const std::string& address);
 
     /*!
      * @brief Creates/opens D-Bus system connection on a remote host using ssh
@@ -258,7 +463,7 @@ namespace sdbus {
      *
      * @throws sdbus::Error in case of failure
      */
-    std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host);
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host);
 }
 
 #endif /* SDBUS_CXX_ICONNECTION_H_ */

include/sdbus-c++/IObject.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file IObject.h
  *
@@ -74,9 +74,37 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual void registerMethod( const std::string& interfaceName
-                                   , const std::string& methodName
-                                   , const std::string& inputSignature
-                                   , const std::string& outputSignature
+                                   , std::string methodName
+                                   , std::string inputSignature
+                                   , std::string outputSignature
+                                   , method_callback methodCallback
+                                   , Flags flags = {} ) = 0;
+
+        /*!
+         * @brief Registers method that the object will provide on D-Bus
+         *
+         * @param[in] interfaceName Name of an interface that the method will belong to
+         * @param[in] methodName Name of the method
+         * @param[in] inputSignature D-Bus signature of method input parameters
+         * @param[in] inputNames Names of input parameters
+         * @param[in] outputSignature D-Bus signature of method output parameters
+         * @param[in] outputNames Names of output parameters
+         * @param[in] methodCallback Callback that implements the body of the method
+         * @param[in] flags D-Bus method flags (privileged, deprecated, or no reply)
+         *
+         * Provided names of input and output parameters will be included in the introspection
+         * description (given that at least version 242 of underlying libsystemd library is
+         * used; otherwise, names of parameters are ignored). This usually helps better describe
+         * the API to the introspector.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void registerMethod( const std::string& interfaceName
+                                   , std::string methodName
+                                   , std::string inputSignature
+                                   , const std::vector<std::string>& inputNames
+                                   , std::string outputSignature
+                                   , const std::vector<std::string>& outputNames
                                    , method_callback methodCallback
                                    , Flags flags = {} ) = 0;
 
@@ -91,8 +119,30 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual void registerSignal( const std::string& interfaceName
-                                   , const std::string& signalName
-                                   , const std::string& signature
+                                   , std::string signalName
+                                   , std::string signature
+                                   , Flags flags = {} ) = 0;
+
+        /*!
+         * @brief Registers signal that the object will emit on D-Bus
+         *
+         * @param[in] interfaceName Name of an interface that the signal will fall under
+         * @param[in] signalName Name of the signal
+         * @param[in] signature D-Bus signature of signal parameters
+         * @param[in] paramNames Names of parameters of the signal
+         * @param[in] flags D-Bus signal flags (deprecated)
+         *
+         * Provided names of signal output parameters will be included in the introspection
+         * description (given that at least version 242 of underlying libsystemd library is
+         * used; otherwise, names of parameters are ignored). This usually helps better describe
+         * the API to the introspector.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void registerSignal( const std::string& interfaceName
+                                   , std::string signalName
+                                   , std::string signature
+                                   , const std::vector<std::string>& paramNames
                                    , Flags flags = {} ) = 0;
 
         /*!
@@ -107,8 +157,8 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual void registerProperty( const std::string& interfaceName
-                                     , const std::string& propertyName
-                                     , const std::string& signature
+                                     , std::string propertyName
+                                     , std::string signature
                                      , property_get_callback getCallback
                                      , Flags flags = {} ) = 0;
 
@@ -125,8 +175,8 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual void registerProperty( const std::string& interfaceName
-                                     , const std::string& propertyName
-                                     , const std::string& signature
+                                     , std::string propertyName
+                                     , std::string signature
                                      , property_get_callback getCallback
                                      , property_set_callback setCallback
                                      , Flags flags = {} ) = 0;
@@ -308,7 +358,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        MethodRegistrator registerMethod(const std::string& methodName);
+        [[nodiscard]] MethodRegistrator registerMethod(const std::string& methodName);
 
         /*!
          * @brief Registers signal that the object will provide on D-Bus
@@ -327,7 +377,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        SignalRegistrator registerSignal(const std::string& signalName);
+        [[nodiscard]] SignalRegistrator registerSignal(const std::string& signalName);
 
         /*!
          * @brief Registers property that the object will provide on D-Bus
@@ -346,7 +396,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        PropertyRegistrator registerProperty(const std::string& propertyName);
+        [[nodiscard]] PropertyRegistrator registerProperty(const std::string& propertyName);
 
         /*!
          * @brief Sets flags (annotations) for a given interface
@@ -363,7 +413,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        InterfaceFlagsSetter setInterfaceFlags(const std::string& interfaceName);
+        [[nodiscard]] InterfaceFlagsSetter setInterfaceFlags(const std::string& interfaceName);
 
         /*!
          * @brief Emits signal on D-Bus
@@ -384,7 +434,28 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        SignalEmitter emitSignal(const std::string& signalName);
+        [[nodiscard]] SignalEmitter emitSignal(const std::string& signalName);
+
+        /*!
+         * @brief Returns object path of the underlying DBus object
+         */
+        virtual const std::string& getObjectPath() const = 0;
+
+        /*!
+         * @brief Provides currently processed D-Bus message
+         *
+         * This method provides immutable access to the currently processed incoming D-Bus message.
+         * "Currently processed" means that the registered callback handler(s) for that message
+         * are being invoked. This method is meant to be called from within a callback handler
+         * (e.g. D-Bus method implementation handler). In such a case it is guaranteed to return
+         * a valid pointer to the D-Bus message for which the handler is called. If called from other
+         * contexts/threads, it may return a nonzero pointer or a nullptr, depending on whether a message
+         * was processed at the time of call or not, but the value is nondereferencable, since the pointed-to
+         * message may have gone in the meantime.
+         *
+         * @return A pointer to the currently processed D-Bus message
+         */
+        virtual const Message* getCurrentlyProcessedMessage() const = 0;
     };
 
     // Out-of-line member definitions
@@ -425,14 +496,14 @@ namespace sdbus {
      * issue signals and provide properties.
      *
      * Creating a D-Bus object instance is (thread-)safe even upon the connection
-     * which is already running its processing loop.
+     * which is already running its I/O event loop.
      *
      * Code example:
      * @code
      * auto proxy = sdbus::createObject(connection, "/com/kistler/foo");
      * @endcode
      */
-    std::unique_ptr<sdbus::IObject> createObject(sdbus::IConnection& connection, std::string objectPath);
+    [[nodiscard]] std::unique_ptr<sdbus::IObject> createObject(sdbus::IConnection& connection, std::string objectPath);
 
 }
 

include/sdbus-c++/IProxy.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file IProxy.h
  *
@@ -38,6 +38,10 @@ namespace sdbus {
     class MethodCall;
     class MethodReply;
     class IConnection;
+    class PendingAsyncCall;
+    namespace internal {
+        class Proxy;
+    }
 }
 
 namespace sdbus {
@@ -108,22 +112,23 @@ namespace sdbus {
          * @param[in] message Message representing an async method call
          * @param[in] asyncReplyCallback Handler for the async reply
          * @param[in] timeout Timeout for dbus call in microseconds
+         * @return Cookie for the the pending asynchronous call
          *
          * The call is non-blocking. It doesn't wait for the reply. Once the reply arrives,
          * the provided async reply handler will get invoked from the context of the connection
-         * event loop processing thread.
+         * I/O event loop thread.
          *
          * Note: To avoid messing with messages, use higher-level API defined below.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual void callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout = 0) = 0;
+        virtual PendingAsyncCall callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout = 0) = 0;
 
         /*!
          * @copydoc IProxy::callMethod(const MethodCall&,async_reply_handler,uint64_t)
          */
         template <typename _Rep, typename _Period>
-        void callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, const std::chrono::duration<_Rep, _Period>& timeout);
+        PendingAsyncCall callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, const std::chrono::duration<_Rep, _Period>& timeout);
 
         /*!
          * @brief Registers a handler for the desired signal emitted by the proxied D-Bus object
@@ -138,6 +143,17 @@ namespace sdbus {
                                           , const std::string& signalName
                                           , signal_handler signalHandler ) = 0;
 
+        /*!
+         * @brief Unregisters the handler of the desired signal
+         *
+         * @param[in] interfaceName Name of an interface that the signal belongs to
+         * @param[in] signalName Name of the signal
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void unregisterSignalHandler( const std::string& interfaceName
+                                            , const std::string& signalName ) = 0;
+
         /*!
          * @brief Finishes the registration of signal handlers
          *
@@ -178,7 +194,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        MethodInvoker callMethod(const std::string& methodName);
+        [[nodiscard]] MethodInvoker callMethod(const std::string& methodName);
 
         /*!
          * @brief Calls method on the proxied D-Bus object asynchronously
@@ -202,7 +218,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        AsyncMethodInvoker callMethodAsync(const std::string& methodName);
+        [[nodiscard]] AsyncMethodInvoker callMethodAsync(const std::string& methodName);
 
         /*!
          * @brief Registers signal handler for a given signal of the proxied D-Bus object
@@ -222,7 +238,24 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        SignalSubscriber uponSignal(const std::string& signalName);
+        [[nodiscard]] SignalSubscriber uponSignal(const std::string& signalName);
+
+        /*!
+         * @brief Unregisters signal handler of a given signal of the proxied D-Bus object
+         *
+         * @param[in] signalName Name of the signal
+         * @return A helper object for convenient unregistration of the signal handler
+         *
+         * This is a high-level, convenience way of unregistering a D-Bus signal's handler.
+         *
+         * Example of use:
+         * @code
+         * object_.muteSignal("fooSignal").onInterface("com.kistler.foo");
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] SignalUnsubscriber muteSignal(const std::string& signalName);
 
         /*!
          * @brief Gets value of a property of the proxied D-Bus object
@@ -241,7 +274,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        PropertyGetter getProperty(const std::string& propertyName);
+        [[nodiscard]] PropertyGetter getProperty(const std::string& propertyName);
 
         /*!
          * @brief Sets value of a property of the proxied D-Bus object
@@ -260,7 +293,77 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        PropertySetter setProperty(const std::string& propertyName);
+        [[nodiscard]] PropertySetter setProperty(const std::string& propertyName);
+
+        /*!
+         * @brief Provides D-Bus connection used by the proxy
+         *
+         * @return Reference to the D-Bus connection
+         */
+        virtual sdbus::IConnection& getConnection() const = 0;
+
+        /*!
+         * @brief Returns object path of the underlying DBus object
+         */
+        virtual const std::string& getObjectPath() const = 0;
+
+        /*!
+         * @brief Provides currently processed D-Bus message
+         *
+         * This method provides immutable access to the currently processed incoming D-Bus message.
+         * "Currently processed" means that the registered callback handler(s) for that message
+         * are being invoked. This method is meant to be called from within a callback handler
+         * (e.g. from a D-Bus signal handler, or async method reply handler, etc.). In such a case it is
+         * guaranteed to return a valid pointer to the D-Bus message for which the handler is called.
+         * If called from other contexts/threads, it may return a nonzero pointer or a nullptr, depending
+         * on whether a message was processed at the time of call or not, but the value is nondereferencable,
+         * since the pointed-to message may have gone in the meantime.
+         *
+         * @return A pointer to the currently processed D-Bus message
+         */
+        virtual const Message* getCurrentlyProcessedMessage() const = 0;
+    };
+
+    /********************************************//**
+     * @class PendingAsyncCall
+     *
+     * PendingAsyncCall represents a simple handle type to cancel the delivery
+     * of the asynchronous D-Bus call result to the application.
+     *
+     * The handle is lifetime-independent from the originating Proxy object.
+     * It's safe to call its methods even after the Proxy has gone.
+     *
+     ***********************************************/
+    class PendingAsyncCall
+    {
+    public:
+        PendingAsyncCall() = default;
+
+        /*!
+         * @brief Cancels the delivery of the pending asynchronous call result
+         *
+         * This function effectively removes the callback handler registered to the
+         * async D-Bus method call result delivery. Does nothing if the call was
+         * completed already, or if the originating Proxy object has gone meanwhile.
+         */
+        void cancel();
+
+        /*!
+         * @brief Answers whether the asynchronous call is still pending
+         *
+         * @return True if the call is pending, false if the call has been fully completed
+         *
+         * Pending call in this context means a call whose results have not arrived, or
+         * have arrived and are currently being processed by the callback handler.
+         */
+        bool isPending() const;
+
+    private:
+        friend internal::Proxy;
+        PendingAsyncCall(std::weak_ptr<void> callData);
+
+    private:
+        std::weak_ptr<void> callData_;
     };
 
     // Out-of-line member definitions
@@ -273,10 +376,10 @@ namespace sdbus {
     }
 
     template <typename _Rep, typename _Period>
-    inline void IProxy::callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, const std::chrono::duration<_Rep, _Period>& timeout)
+    inline PendingAsyncCall IProxy::callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, const std::chrono::duration<_Rep, _Period>& timeout)
     {
         auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
-        callMethod(message, std::move(asyncReplyCallback), microsecs.count());
+        return callMethod(message, std::move(asyncReplyCallback), microsecs.count());
     }
 
     inline MethodInvoker IProxy::callMethod(const std::string& methodName)
@@ -294,6 +397,11 @@ namespace sdbus {
         return SignalSubscriber(*this, signalName);
     }
 
+    inline SignalUnsubscriber IProxy::muteSignal(const std::string& signalName)
+    {
+        return SignalUnsubscriber(*this, signalName);
+    }
+
     inline PropertyGetter IProxy::getProperty(const std::string& propertyName)
     {
         return PropertyGetter(*this, propertyName);
@@ -315,7 +423,7 @@ 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. The caller still
      * remains the owner of the connection (the proxy just keeps a reference to it), and
-     * should make sure that a processing loop is running on that connection, so the proxy
+     * should make sure that an I/O event loop is running on that connection, so the proxy
      * may receive incoming signals and asynchronous method replies.
      *
      * Code example:
@@ -323,9 +431,9 @@ namespace sdbus {
      * auto proxy = sdbus::createProxy(connection, "com.kistler.foo", "/com/kistler/foo");
      * @endcode
      */
-    std::unique_ptr<sdbus::IProxy> createProxy( sdbus::IConnection& connection
-                                              , std::string destination
-                                              , std::string objectPath );
+    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( sdbus::IConnection& connection
+                                                            , std::string destination
+                                                            , std::string objectPath );
 
     /*!
      * @brief Creates a proxy object for a specific remote D-Bus object
@@ -346,9 +454,9 @@ namespace sdbus {
      * auto proxy = sdbus::createProxy(std::move(connection), "com.kistler.foo", "/com/kistler/foo");
      * @endcode
      */
-    std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<sdbus::IConnection>&& connection
-                                              , std::string destination
-                                              , std::string objectPath );
+    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<sdbus::IConnection>&& connection
+                                                            , std::string destination
+                                                            , std::string objectPath );
 
     /*!
      * @brief Creates a proxy object for a specific remote D-Bus object
@@ -367,8 +475,8 @@ namespace sdbus {
      * auto proxy = sdbus::createProxy("com.kistler.foo", "/com/kistler/foo");
      * @endcode
      */
-    std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
-                                              , std::string objectPath );
+    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
+                                                            , std::string objectPath );
 
 }
 

include/sdbus-c++/Message.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Message.h
  *
@@ -32,11 +32,11 @@
 #include <string>
 #include <vector>
 #include <map>
-#include <memory>
 #include <utility>
 #include <cstdint>
 #include <cassert>
 #include <functional>
+#include <sys/types.h>
 
 // Forward declarations
 namespace sdbus {
@@ -44,29 +44,21 @@ namespace sdbus {
     class ObjectPath;
     class Signature;
     template <typename... _ValueTypes> class Struct;
-    struct UnixFd;
+    class UnixFd;
     class MethodReply;
     namespace internal {
         class ISdBus;
+        class IConnection;
     }
 }
 
 namespace sdbus {
 
-    // Assume the caller has already obtained message ownership
-    struct adopt_message_t { explicit adopt_message_t() = default; };
-#ifdef __cpp_inline_variables
-    inline constexpr adopt_message_t adopt_message{};
-#else
-    constexpr adopt_message_t adopt_message{};
-#endif
-
     /********************************************//**
      * @class Message
      *
      * Message represents a D-Bus message, which can be either method call message,
-     * method reply message, signal message, or a plain message serving as a storage
-     * for serialized data.
+     * method reply message, signal message, or a plain message.
      *
      * Serialization and deserialization functions are provided for types supported
      * by D-Bus.
@@ -75,7 +67,7 @@ namespace sdbus {
      * of @c IObject and @c IProxy.
      *
      ***********************************************/
-    class Message
+    class [[nodiscard]] Message
     {
     public:
         Message& operator<<(bool item);
@@ -134,6 +126,8 @@ namespace sdbus {
         std::string getInterfaceName() const;
         std::string getMemberName() const;
         std::string getSender() const;
+        std::string getPath() const;
+        std::string getDestination() const;
         void peekType(std::string& type, std::string& contents) const;
         bool isValid() const;
         bool isEmpty() const;
@@ -142,6 +136,14 @@ namespace sdbus {
         void seal();
         void rewind(bool complete);
 
+        pid_t getCredsPid() const;
+        uid_t getCredsUid() const;
+        uid_t getCredsEuid() const;
+        gid_t getCredsGid() const;
+        gid_t getCredsEgid() const;
+        std::vector<gid_t> getCredsSupplementaryGids() const;
+        std::string getSELinuxContext() const;
+
         class Factory;
 
     protected:
@@ -165,21 +167,17 @@ namespace sdbus {
         mutable bool ok_{true};
     };
 
-    struct dont_request_slot_t { explicit dont_request_slot_t() = default; };
-    inline constexpr dont_request_slot_t dont_request_slot{};
-
     class MethodCall : public Message
     {
         using Message::Message;
         friend Factory;
 
     public:
-        using Slot = std::unique_ptr<void, std::function<void(void*)>>;
-
         MethodCall() = default;
 
         MethodReply send(uint64_t timeout) const;
-        void send(void* callback, void* userData, uint64_t timeout, dont_request_slot_t) const;
+        [[deprecated("Use send overload with floating_slot instead")]] void send(void* callback, void* userData, uint64_t timeout, dont_request_slot_t) const;
+        void send(void* callback, void* userData, uint64_t timeout, floating_slot_t) const;
         [[nodiscard]] Slot send(void* callback, void* userData, uint64_t timeout) const;
 
         MethodReply createReply() const;
@@ -188,9 +186,13 @@ namespace sdbus {
         void dontExpectReply();
         bool doesntExpectReply() const;
 
+    protected:
+        MethodCall(void *msg, internal::ISdBus* sdbus, const internal::IConnection* connection, adopt_message_t) noexcept;
+
     private:
         MethodReply sendWithReply(uint64_t timeout = 0) const;
         MethodReply sendWithNoReply() const;
+        const internal::IConnection* connection_{};
     };
 
     class MethodReply : public Message
@@ -210,6 +212,7 @@ namespace sdbus {
 
     public:
         Signal() = default;
+        void setDestination(const std::string& destination);
         void send() const;
     };
 
@@ -231,6 +234,7 @@ namespace sdbus {
         PropertyGetReply() = default;
     };
 
+    // Represents any of the above message types, or just a message that serves as a container for data
     class PlainMessage : public Message
     {
         using Message::Message;
@@ -279,10 +283,7 @@ namespace sdbus {
         template <typename... _Args>
         void serialize_pack(Message& msg, _Args&&... args)
         {
-            // Use initializer_list because it guarantees left to right order, and can be empty
-            using _ = std::initializer_list<int>;
-            // We are not interested in the list itself, but in the side effects
-            (void)_{(void(msg << std::forward<_Args>(args)), 0)...};
+            (void)(msg << ... << args);
         }
 
         template <class _Tuple, std::size_t... _Is>
@@ -374,10 +375,7 @@ namespace sdbus {
         template <typename... _Args>
         void deserialize_pack(Message& msg, _Args&... args)
         {
-            // Use initializer_list because it guarantees left to right order, and can be empty
-            using _ = std::initializer_list<int>;
-            // We are not interested in the list itself, but in the side effects
-            (void)_{(void(msg >> args), 0)...};
+            (void)(msg >> ... >> args);
         }
 
         template <class _Tuple, std::size_t... _Is>

include/sdbus-c++/MethodResult.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file MethodResult.h
  *
@@ -76,12 +76,7 @@ namespace sdbus {
     {
         assert(call_.isValid());
         auto reply = call_.createReply();
-#ifdef __cpp_fold_expressions
         (reply << ... << results);
-#else
-        using _ = std::initializer_list<int>;
-        (void)_{(void(reply << results), 0)...};
-#endif
         reply.send();
     }
 

include/sdbus-c++/ProxyInterfaces.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file ProxyInterfaces.h
  *
@@ -165,8 +165,17 @@ namespace sdbus {
             getProxy().unregister();
         }
 
+        /*!
+         * @brief Returns object path of the underlying DBus object
+         */
+        const std::string& getObjectPath() const
+        {
+            return getProxy().getObjectPath();
+        }
+
     protected:
         using base_type = ProxyInterfaces;
+        ~ProxyInterfaces() = default;
     };
 
 }

include/sdbus-c++/SdbusAsio.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include <boost/asio.hpp>
+#include <boost/noncopyable.hpp>
+#include <memory>
+#include <sdbus-c++/sdbus-c++.h>
+
+class SdbusAsio final : boost::noncopyable {
+public:
+    explicit SdbusAsio(boost::asio::io_context& io_context,
+        std::unique_ptr<sdbus::IConnection> conn = sdbus::createDefaultBusConnection())
+        : conn_ { std::move(conn) }
+        , timer_ { io_context }
+        , dbus_desc_ { io_context }
+        , event_desc_ { io_context }
+
+    {
+        auto poll_data = conn_->getEventLoopPollData();
+        dbus_desc_.async_wait(boost::asio::posix::stream_descriptor::wait_read,
+            [this](const boost::system::error_code&) { processRead(); });
+        dbus_desc_.assign(poll_data.fd);
+
+        event_desc_.async_read_some(boost::asio::null_buffers(), [this](auto&, auto) { processEvent(); });
+        event_desc_.assign(poll_data.event_fd);
+
+        if (poll_data.timeout_usec != UINT64_MAX) {
+            timer_.async_wait([this](boost::system::error_code const&) { processTimeout(); });
+            timer_.expires_after(boost::posix_time::microsec(poll_data.timeout_usec));
+        }
+    }
+
+    std::shared_ptr<sdbus::IConnection> getConnection() { return conn_; }
+
+private:
+    void process()
+    {
+        for (auto i = 0; i < DBUS_PROCESS_MAX; i++) {
+            if (!conn_->processPendingRequest()) {
+                break;
+            }
+        }
+    }
+    void processRead()
+    {
+        process();
+        dbus_desc_.async_wait(boost::asio::posix::stream_descriptor::wait_read,
+            [this](const boost::system::error_code&) { processRead(); });
+    }
+
+    void processEvent()
+    {
+        process();
+        event_desc_.async_read_some(boost::asio::null_buffers(), [this](auto, auto) { processEvent(); });
+    }
+
+    void processTimeout()
+    {
+        process();
+        timer_.async_wait([this](boost::system::error_code const&) { processTimeout(); });
+    }
+
+    static constexpr auto DBUS_PROCESS_MAX = 32;
+    std::shared_ptr<sdbus::IConnection> conn_;
+    boost::asio::deadline_timer timer_;
+    boost::asio::posix::stream_descriptor dbus_desc_;
+    boost::asio::posix::stream_descriptor event_desc_;
+};

include/sdbus-c++/StandardInterfaces.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file StandardInterfaces.h
  *
@@ -187,8 +187,8 @@ namespace sdbus {
     };
 
     // Adaptors for the above-listed standard D-Bus interfaces are not necessary because the functionality
-    // is provided by underlying libsystemd implementation. The exception is Properties_adaptor and
-    // ObjectManager_adaptor, which provide convenience functionality to emit signals.
+    // is provided by underlying libsystemd implementation. The exception is Properties_adaptor,
+    // ObjectManager_adaptor and ManagedObject_adaptor, which provide convenience functionality to emit signals.
 
     // Adaptor for properties
     class Properties_adaptor
@@ -218,13 +218,22 @@ namespace sdbus {
         sdbus::IObject& object_;
     };
 
-    // Adaptor for object manager
+    /*!
+     * @brief Object Manager Convenience Adaptor
+     *
+     * Adding this class as _Interfaces.. template parameter of class AdaptorInterfaces
+     * implements the *GetManagedObjects()* method of the [org.freedesktop.DBus.ObjectManager.GetManagedObjects](https://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
+     * interface.
+     *
+     * Note that there can be multiple object managers in a path hierarchy. InterfacesAdded/InterfacesRemoved
+     * signals are sent from the closest object manager at either the same path or the closest parent path of an object.
+     */
     class ObjectManager_adaptor
     {
         static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.ObjectManager";
 
     protected:
-        ObjectManager_adaptor(sdbus::IObject& object)
+        explicit ObjectManager_adaptor(sdbus::IObject& object)
             : object_(object)
         {
             object_.addObjectManager();
@@ -232,22 +241,66 @@ namespace sdbus {
 
         ~ObjectManager_adaptor() = default;
 
+    private:
+        sdbus::IObject& object_;
+    };
+
+    /*!
+     * @brief Managed Object Convenience Adaptor
+     *
+     * Adding this class as _Interfaces.. template parameter of class AdaptorInterfaces
+     * will extend the resulting object adaptor with emitInterfacesAddedSignal()/emitInterfacesRemovedSignal()
+     * according to org.freedesktop.DBus.ObjectManager.InterfacesAdded/.InterfacesRemoved.
+     *
+     * Note that objects which implement this adaptor require an object manager (e.g via ObjectManager_adaptor) to be
+     * instantiated on one of it's parent object paths or the same path. InterfacesAdded/InterfacesRemoved
+     * signals are sent from the closest object manager at either the same path or the closest parent path of an object.
+     */
+    class ManagedObject_adaptor
+    {
+    protected:
+        explicit ManagedObject_adaptor(sdbus::IObject& object) : object_(object)
+        {
+        }
+
+        ~ManagedObject_adaptor() = default;
+
     public:
+        /*!
+         * @brief Emits InterfacesAdded signal for this object path
+         *
+         * See IObject::emitInterfacesAddedSignal().
+         */
         void emitInterfacesAddedSignal()
         {
             object_.emitInterfacesAddedSignal();
         }
 
+        /*!
+         * @brief Emits InterfacesAdded signal for this object path
+         *
+         * See IObject::emitInterfacesAddedSignal().
+         */
         void emitInterfacesAddedSignal(const std::vector<std::string>& interfaces)
         {
             object_.emitInterfacesAddedSignal(interfaces);
         }
 
+        /*!
+         * @brief Emits InterfacesRemoved signal for this object path
+         *
+         * See IObject::emitInterfacesRemovedSignal().
+         */
         void emitInterfacesRemovedSignal()
         {
             object_.emitInterfacesRemovedSignal();
         }
 
+        /*!
+         * @brief Emits InterfacesRemoved signal for this object path
+         *
+         * See IObject::emitInterfacesRemovedSignal().
+         */
         void emitInterfacesRemovedSignal(const std::vector<std::string>& interfaces)
         {
             object_.emitInterfacesRemovedSignal(interfaces);

include/sdbus-c++/TypeTraits.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file TypeTraits.h
  *
@@ -33,6 +33,7 @@
 #include <map>
 #include <cstdint>
 #include <functional>
+#include <memory>
 #include <tuple>
 
 // Forward declarations
@@ -41,10 +42,11 @@ namespace sdbus {
     template <typename... _ValueTypes> class Struct;
     class ObjectPath;
     class Signature;
-    struct UnixFd;
+    class UnixFd;
     class MethodCall;
     class MethodReply;
     class Signal;
+    class Message;
     class PropertySetCall;
     class PropertyGetReply;
     template <typename... _Results> class Result;
@@ -53,12 +55,34 @@ namespace sdbus {
 
 namespace sdbus {
 
+    // Callbacks from sdbus-c++
     using method_callback = std::function<void(MethodCall msg)>;
     using async_reply_handler = std::function<void(MethodReply& reply, const Error* error)>;
     using signal_handler = std::function<void(Signal& signal)>;
+    using message_handler = std::function<void(Message& msg)>;
     using property_set_callback = std::function<void(PropertySetCall& msg)>;
     using property_get_callback = std::function<void(PropertyGetReply& reply)>;
 
+    // Type-erased RAII-style handle to callbacks/subscriptions registered to sdbus-c++
+    using Slot = std::unique_ptr<void, std::function<void(void*)>>;
+
+    // Tag specifying that an owning slot handle shall be returned from the function
+    struct request_slot_t { explicit request_slot_t() = default; };
+    inline constexpr request_slot_t request_slot{};
+    // Tag specifying that the library shall own the slot resulting from the call of the function (so-called floating slot)
+    struct floating_slot_t { explicit floating_slot_t() = default; };
+    inline constexpr floating_slot_t floating_slot{};
+    // Deprecated name for the above -- a floating slot
+    struct dont_request_slot_t { explicit dont_request_slot_t() = default; };
+    [[deprecated("Replaced by floating_slot")]] inline constexpr dont_request_slot_t dont_request_slot{};
+    // Tag denoting the assumption that the caller has already obtained message ownership
+    struct adopt_message_t { explicit adopt_message_t() = default; };
+    inline constexpr adopt_message_t adopt_message{};
+    // Tag denoting the assumption that the caller has already obtained fd ownership
+    struct adopt_fd_t { explicit adopt_fd_t() = default; };
+    inline constexpr adopt_fd_t adopt_fd{};
+
+    // Template specializations for getting D-Bus signatures from C++ types
     template <typename _T>
     struct signature_of
     {
@@ -245,11 +269,9 @@ namespace sdbus {
 
         static const std::string str()
         {
-            std::initializer_list<std::string> signatures{signature_of<_ValueTypes>::str()...};
             std::string signature;
             signature += "(";
-            for (const auto& item : signatures)
-                signature += item;
+            (signature += ... += signature_of<_ValueTypes>::str());
             signature += ")";
             return signature;
         }
@@ -380,12 +402,14 @@ namespace sdbus {
         : public function_traits_base<_ReturnType, _Args...>
     {
         static constexpr bool is_async = false;
+        static constexpr bool has_error_param = false;
     };
 
     template <typename... _Args>
     struct function_traits<void(const Error*, _Args...)>
         : public function_traits_base<void, _Args...>
     {
+        static constexpr bool has_error_param = true;
     };
 
     template <typename... _Args, typename... _Results>
@@ -445,6 +469,9 @@ namespace sdbus {
     template <class _Function>
     constexpr auto is_async_method_v = function_traits<_Function>::is_async;
 
+    template <class _Function>
+    constexpr auto has_error_param_v = function_traits<_Function>::has_error_param;
+
     template <typename _FunctionType>
     using function_arguments_t = typename function_traits<_FunctionType>::arguments_type;
 
@@ -489,11 +516,8 @@ namespace sdbus {
     {
         static const std::string str()
         {
-            // TODO: This could be a fold expression in C++17...
-            std::initializer_list<std::string> signatures{signature_of<std::decay_t<_Types>>::str()...};
             std::string signature;
-            for (const auto& item : signatures)
-                signature += item;
+            (void)(signature += ... += signature_of<std::decay_t<_Types>>::str());
             return signature;
         }
     };
@@ -536,27 +560,17 @@ namespace sdbus {
             return std::forward<_Function>(f)(e, std::get<_I>(std::forward<_Tuple>(t))...);
         }
 
-        // Version of apply_impl for functions returning non-void values.
-        // In this case just forward function return value.
+        // For non-void returning functions, apply_impl simply returns function return value (a tuple of values).
+        // For void-returning functions, apply_impl returns an empty tuple.
         template <class _Function, class _Tuple, std::size_t... _I>
         constexpr decltype(auto) apply_impl( _Function&& f
                                            , _Tuple&& t
-                                           , std::index_sequence<_I...>
-                                           , std::enable_if_t<!std::is_void<function_result_t<_Function>>::value>* = nullptr)
+                                           , std::index_sequence<_I...> )
         {
-            return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...);
-        }
-
-        // Version of apply_impl for functions returning void.
-        // In this case, to have uniform code on the caller side, return empty tuple, our synonym for `void'.
-        template <class _Function, class _Tuple, std::size_t... _I>
-        constexpr decltype(auto) apply_impl( _Function&& f
-                                           , _Tuple&& t
-                                           , std::index_sequence<_I...>
-                                           , std::enable_if_t<std::is_void<function_result_t<_Function>>::value>* = nullptr)
-        {
-            std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...);
-            return std::tuple<>{};
+            if constexpr (!std::is_void_v<function_result_t<_Function>>)
+                return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...);
+            else
+                return std::forward<_Function>(f)(std::get<_I>(std::forward<_Tuple>(t))...), std::tuple<>{};
         }
     }
 

include/sdbus-c++/Types.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Types.h
  *
@@ -154,6 +154,10 @@ namespace sdbus {
     public:
         using std::string::string;
         ObjectPath() = default; // Fixes gcc 6.3 error (default c-tor is not imported in above using declaration)
+        ObjectPath(const ObjectPath&) = default; // Fixes gcc 8.3 error (deleted copy constructor)
+        ObjectPath(ObjectPath&&) = default; // Enable move - user-declared copy ctor prevents implicit creation
+        ObjectPath& operator = (const ObjectPath&) = default; // Fixes gcc 8.3 error (deleted copy assignment)
+        ObjectPath& operator = (ObjectPath&&) = default; // Enable move - user-declared copy assign prevents implicit creation
         ObjectPath(std::string path)
             : std::string(std::move(path))
         {}
@@ -171,19 +175,16 @@ namespace sdbus {
     public:
         using std::string::string;
         Signature() = default; // Fixes gcc 6.3 error (default c-tor is not imported in above using declaration)
+        Signature(const Signature&) = default; // Fixes gcc 8.3 error (deleted copy constructor)
+        Signature(Signature&&) = default; // Enable move - user-declared copy ctor prevents implicit creation
+        Signature& operator = (const Signature&) = default; // Fixes gcc 8.3 error (deleted copy assignment)
+        Signature& operator = (Signature&&) = default; // Enable move - user-declared copy assign prevents implicit creation
         Signature(std::string path)
             : std::string(std::move(path))
         {}
         using std::string::operator=;
     };
 
-    struct adopt_fd_t { explicit adopt_fd_t() = default; };
-#ifdef __cpp_inline_variables
-    inline constexpr adopt_fd_t adopt_fd{};
-#else
-    constexpr adopt_fd_t adopt_fd{};
-#endif
-
     /********************************************//**
      * @struct UnixFd
      *

include/sdbus-c++/sdbus-c++.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file sdbus-c++.h
  *

pkgconfig/sdbus-c++.pc.in

@@ -5,7 +5,7 @@ includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
 
 Name: @PROJECT_NAME@
 Description: C++ library on top of sd-bus, a systemd D-Bus library
-Requires: libsystemd
+Requires@PKGCONFIG_REQS@: libsystemd
 Version: @SDBUSCPP_VERSION@
 Libs: -L${libdir} -l@PROJECT_NAME@
 Cflags: -I${includedir}

src/Connection.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Connection.cpp
  *
@@ -27,6 +27,7 @@
 #include "Connection.h"
 #include "SdBus.h"
 #include "MessageUtils.h"
+#include "Utils.h"
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/Error.h>
 #include "ScopeGuard.h"
@@ -35,7 +36,7 @@
 #include <poll.h>
 #include <sys/eventfd.h>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 Connection::Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& busFactory)
     : iface_(std::move(interface))
@@ -44,6 +45,11 @@ Connection::Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& bu
     assert(iface_ != nullptr);
 }
 
+Connection::Connection(std::unique_ptr<ISdBus>&& interface, default_bus_t)
+    : Connection(std::move(interface), [this](sd_bus** bus){ return iface_->sd_bus_open(bus); })
+{
+}
+
 Connection::Connection(std::unique_ptr<ISdBus>&& interface, system_bus_t)
     : Connection(std::move(interface), [this](sd_bus** bus){ return iface_->sd_bus_open_system(bus); })
 {
@@ -54,18 +60,37 @@ Connection::Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t)
 {
 }
 
+Connection::Connection(std::unique_ptr<ISdBus>&& interface, custom_session_bus_t, const std::string& address)
+        : Connection(std::move(interface), [&](sd_bus** bus) { return iface_->sd_bus_open_user_with_address(bus, address.c_str()); })
+{
+}
+
 Connection::Connection(std::unique_ptr<ISdBus>&& interface, remote_system_bus_t, const std::string& host)
     : Connection(std::move(interface), [this, &host](sd_bus** bus){ return iface_->sd_bus_open_system_remote(bus, host.c_str()); })
 {
 }
 
+Connection::Connection(std::unique_ptr<ISdBus>&& interface, pseudo_bus_t)
+    : iface_(std::move(interface))
+    , bus_(openPseudoBus())
+{
+    assert(iface_ != nullptr);
+    eventFd_.fd = eventfd(0, 0);
+    assert(eventFd_.fd >= 0);
+}
+
 Connection::~Connection()
 {
-    leaveProcessingLoop();
+    Connection::leaveEventLoop();
+    if (0 <= eventFd_.fd) {
+        close(eventFd_.fd);
+    }
 }
 
 void Connection::requestName(const std::string& name)
 {
+    SDBUS_CHECK_SERVICE_NAME(name);
+
     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);
 }
@@ -84,9 +109,10 @@ std::string Connection::getUniqueName() const
     return unique;
 }
 
-void Connection::enterProcessingLoop()
+void Connection::enterEventLoop()
 {
     loopThreadId_ = std::this_thread::get_id();
+    SCOPE_EXIT{ loopThreadId_ = std::thread::id{}; };
 
     std::lock_guard guard(loopMutex_);
 
@@ -98,31 +124,29 @@ void Connection::enterProcessingLoop()
 
         auto success = waitForNextRequest();
         if (!success)
-            break; // Exit processing loop
+            break; // Exit I/O event loop
     }
-
-    loopThreadId_ = std::thread::id{};
 }
 
-void Connection::enterProcessingLoopAsync()
+void Connection::enterEventLoopAsync()
 {
     if (!asyncLoopThread_.joinable())
-        asyncLoopThread_ = std::thread([this](){ enterProcessingLoop(); });
+        asyncLoopThread_ = std::thread([this](){ enterEventLoop(); });
 }
 
-void Connection::leaveProcessingLoop()
+void Connection::leaveEventLoop()
 {
-    notifyProcessingLoopToExit();
-    joinWithProcessingLoop();
+    notifyEventLoopToExit();
+    joinWithEventLoop();
 }
 
-sdbus::IConnection::PollData Connection::getProcessLoopPollData() const
+Connection::PollData Connection::getEventLoopPollData() const
 {
-    ISdBus::PollData pollData;
+    ISdBus::PollData pollData{};
     auto r = iface_->sd_bus_get_poll_data(bus_.get(), &pollData);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus poll data", -r);
 
-    return {pollData.fd, pollData.events, pollData.timeout_usec};
+    return {pollData.fd, pollData.events, pollData.timeout_usec, eventFd_.fd};
 }
 
 const ISdBus& Connection::getSdBusInterface() const
@@ -137,16 +161,21 @@ ISdBus& Connection::getSdBusInterface()
 
 void Connection::addObjectManager(const std::string& objectPath)
 {
-    Connection::addObjectManager(objectPath, nullptr);
+    Connection::addObjectManager(objectPath, floating_slot);
 }
 
-SlotPtr Connection::addObjectManager(const std::string& objectPath, void* /*dummy*/)
+void Connection::addObjectManager(const std::string& objectPath, floating_slot_t)
+{
+    auto r = iface_->sd_bus_add_object_manager(bus_.get(), nullptr, objectPath.c_str());
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add object manager", -r);
+}
+
+Slot Connection::addObjectManager(const std::string& objectPath, request_slot_t)
 {
     sd_bus_slot *slot{};
 
-    auto r = iface_->sd_bus_add_object_manager( bus_.get()
-                                              , &slot
-                                              , objectPath.c_str() );
+    auto r = iface_->sd_bus_add_object_manager(bus_.get(), &slot, objectPath.c_str());
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to add object manager", -r);
 
@@ -171,10 +200,38 @@ uint64_t Connection::getMethodCallTimeout() const
     return timeout;
 }
 
-SlotPtr Connection::addObjectVTable( const std::string& objectPath
-                                   , const std::string& interfaceName
-                                   , const sd_bus_vtable* vtable
-                                   , void* userData )
+Slot Connection::addMatch(const std::string& match, message_handler callback)
+{
+    auto matchInfo = std::make_unique<MatchInfo>(MatchInfo{std::move(callback), *this, {}});
+
+    auto messageHandler = [](sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/) -> int
+    {
+        auto* matchInfo = static_cast<MatchInfo*>(userData);
+        auto message = Message::Factory::create<PlainMessage>(sdbusMessage, &matchInfo->connection.getSdBusInterface());
+        matchInfo->callback(message);
+        return 0;
+    };
+
+    auto r = iface_->sd_bus_add_match(bus_.get(), &matchInfo->slot, match.c_str(), std::move(messageHandler), matchInfo.get());
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add match", -r);
+
+    return {matchInfo.release(), [this](void *ptr)
+    {
+        auto* matchInfo = static_cast<MatchInfo*>(ptr);
+        iface_->sd_bus_slot_unref(matchInfo->slot);
+        std::default_delete<MatchInfo>{}(matchInfo);
+    }};
+}
+
+void Connection::addMatch(const std::string& match, message_handler callback, floating_slot_t)
+{
+    floatingMatchRules_.push_back(addMatch(match, std::move(callback)));
+}
+
+Slot Connection::addObjectVTable( const std::string& objectPath
+                                , const std::string& interfaceName
+                                , const sd_bus_vtable* vtable
+                                , void* userData )
 {
     sd_bus_slot *slot{};
 
@@ -190,6 +247,17 @@ SlotPtr Connection::addObjectVTable( const std::string& objectPath
     return {slot, [this](void *slot){ iface_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }
 
+PlainMessage Connection::createPlainMessage() const
+{
+    sd_bus_message* sdbusMsg{};
+
+    auto r = iface_->sd_bus_message_new(bus_.get(), &sdbusMsg, _SD_BUS_MESSAGE_TYPE_INVALID);
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create a plain message", -r);
+
+    return Message::Factory::create<PlainMessage>(sdbusMsg, iface_.get(), adopt_message);
+}
+
 MethodCall Connection::createMethodCall( const std::string& destination
                                        , const std::string& objectPath
                                        , const std::string& interfaceName
@@ -206,24 +274,24 @@ MethodCall Connection::createMethodCall( const std::string& destination
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method call", -r);
 
-    return Message::Factory::create<MethodCall>(sdbusMsg, iface_.get(), adopt_message);
+    return Message::Factory::create<MethodCall>(sdbusMsg, iface_.get(), this, adopt_message);
 }
 
 Signal Connection::createSignal( const std::string& objectPath
                                , const std::string& interfaceName
                                , const std::string& signalName ) const
 {
-    sd_bus_message *sdbusSignal{};
+    sd_bus_message *sdbusMsg{};
 
     auto r = iface_->sd_bus_message_new_signal( bus_.get()
-                                              , &sdbusSignal
+                                              , &sdbusMsg
                                               , objectPath.c_str()
                                               , interfaceName.c_str()
                                               , signalName.c_str() );
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to create signal", -r);
 
-    return Message::Factory::create<Signal>(sdbusSignal, iface_.get(), adopt_message);
+    return Message::Factory::create<Signal>(sdbusMsg, iface_.get(), adopt_message);
 }
 
 void Connection::emitPropertiesChangedSignal( const std::string& objectPath
@@ -278,15 +346,19 @@ void Connection::emitInterfacesRemovedSignal( const std::string& objectPath
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit InterfacesRemoved signal", -r);
 }
 
-SlotPtr Connection::registerSignalHandler( const std::string& objectPath
-                                         , const std::string& interfaceName
-                                         , const std::string& signalName
-                                         , sd_bus_message_handler_t callback
-                                         , void* userData )
+Slot Connection::registerSignalHandler( const std::string& sender
+                                      , 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);
+    // Alternatively to our own composeSignalMatchFilter() implementation, we could use sd_bus_match_signal() from
+    // https://www.freedesktop.org/software/systemd/man/sd_bus_add_match.html .
+    // But this would require libsystemd v237 or higher.
+    auto filter = composeSignalMatchFilter(sender, objectPath, interfaceName, signalName);
     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);
@@ -334,6 +406,23 @@ Connection::BusPtr Connection::openBus(const BusFactory& busFactory)
     return busPtr;
 }
 
+Connection::BusPtr Connection::openPseudoBus()
+{
+    sd_bus* bus{};
+
+    int r = iface_->sd_bus_new(&bus);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to open pseudo bus", -r);
+
+    (void)iface_->sd_bus_start(bus);
+    // It is expected that sd_bus_start has failed here, returning -EINVAL, due to having
+    // not set a bus address, but it will leave the bus in an OPENING state, which enables
+    // us to create plain D-Bus messages as a local data storage (for Variant, for example),
+    // without dependency on real IPC communication with the D-Bus broker daemon.
+    SDBUS_THROW_ERROR_IF(r < 0 && r != -EINVAL, "Failed to start pseudo bus", -r);
+
+    return {bus, [this](sd_bus* bus){ return iface_->sd_bus_close_unref(bus); }};
+}
+
 void Connection::finishHandshake(sd_bus* bus)
 {
     // Process all requests that are part of the initial handshake,
@@ -347,23 +436,46 @@ void Connection::finishHandshake(sd_bus* bus)
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to flush bus on opening", -r);
 }
 
-void Connection::notifyProcessingLoopToExit()
+void Connection::notifyEventLoop(int fd) const
 {
-    assert(loopExitFd_.fd >= 0);
+    assert(fd >= 0);
 
     uint64_t value = 1;
-    auto r = write(loopExitFd_.fd, &value, sizeof(value));
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to notify processing loop", -errno);
+    auto r = write(fd, &value, sizeof(value));
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to notify event loop", -errno);
 }
 
-void Connection::clearExitNotification()
+void Connection::notifyEventLoopToExit() const
+{
+    notifyEventLoop(loopExitFd_.fd);
+}
+
+void Connection::notifyEventLoop() const
+{
+    notifyEventLoop(eventFd_.fd);
+}
+
+void Connection::notifyEventLoopNewTimeout() const
+{
+    // The extra notifications for new timeouts are only needed if calls are made asynchronously to the event loop.
+    // Are we in the same thread as the event loop? Note that it's ok to fail this check because the event loop isn't yet started.
+    if (loopThreadId_.load(std::memory_order_relaxed) == std::this_thread::get_id())
+        return;
+
+    // Get the new timeout from sd-bus
+    auto sdbusPollData = getEventLoopPollData();
+    if (sdbusPollData.timeout_usec < activeTimeout_.load(std::memory_order_relaxed))
+        notifyEventLoop(eventFd_.fd);
+}
+
+void Connection::clearEventLoopNotification(int fd) const
 {
     uint64_t value{};
-    auto r = read(loopExitFd_.fd, &value, sizeof(value));
+    auto r = read(fd, &value, sizeof(value));
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to read from the event descriptor", -errno);
 }
 
-void Connection::joinWithProcessingLoop()
+void Connection::joinWithEventLoop()
 {
     if (asyncLoopThread_.joinable())
         asyncLoopThread_.join();
@@ -382,16 +494,19 @@ bool Connection::processPendingRequest()
 
 bool Connection::waitForNextRequest()
 {
-    auto bus = bus_.get();
+    assert(bus_ != nullptr);
+    assert(eventFd_.fd >= 0);
 
-    assert(bus != nullptr);
-    assert(loopExitFd_.fd != 0);
-
-    auto sdbusPollData = getProcessLoopPollData();
-    struct pollfd fds[] = {{sdbusPollData.fd, sdbusPollData.events, 0}, {loopExitFd_.fd, POLLIN, 0}};
+    auto sdbusPollData = getEventLoopPollData();
+    struct pollfd fds[] = {
+            {sdbusPollData.fd, sdbusPollData.events, 0},
+            {eventFd_.fd, POLLIN, 0},
+            {loopExitFd_.fd, POLLIN, 0}
+    };
     auto fdsCount = sizeof(fds)/sizeof(fds[0]);
 
-    auto timeout = sdbusPollData.timeout_usec == (uint64_t) -1 ? (uint64_t)-1 : (sdbusPollData.timeout_usec+999)/1000;
+    auto timeout = sdbusPollData.getPollTimeout();
+    activeTimeout_.store(sdbusPollData.timeout_usec, std::memory_order_relaxed);
     auto r = poll(fds, fdsCount, timeout);
 
     if (r < 0 && errno == EINTR)
@@ -399,22 +514,30 @@ bool Connection::waitForNextRequest()
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to wait on the bus", -errno);
 
+    // new timeout notification
     if (fds[1].revents & POLLIN)
     {
-        clearExitNotification();
+        clearEventLoopNotification(fds[1].fd);
+    }
+    // loop exit notification
+    if (fds[2].revents & POLLIN)
+    {
+        clearEventLoopNotification(fds[2].fd);
         return false;
     }
 
     return true;
 }
 
-std::string Connection::composeSignalMatchFilter( const std::string& objectPath
-                                                , const std::string& interfaceName
-                                                , const std::string& signalName )
+std::string Connection::composeSignalMatchFilter( const std::string &sender
+                                                , const std::string &objectPath
+                                                , const std::string &interfaceName
+                                                , const std::string &signalName )
 {
     std::string filter;
 
     filter += "type='signal',";
+    filter += "sender='" + sender + "',";
     filter += "interface='" + interfaceName + "',";
     filter += "member='" + signalName + "',";
     filter += "path='" + objectPath + "'";
@@ -431,22 +554,71 @@ std::vector</*const */char*> Connection::to_strv(const std::vector<std::string>&
     return strv;
 }
 
-Connection::LoopExitEventFd::LoopExitEventFd()
+Connection::EventFd::EventFd()
 {
-    fd = eventfd(0, EFD_SEMAPHORE | EFD_CLOEXEC | EFD_NONBLOCK);
+    fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
     SDBUS_THROW_ERROR_IF(fd < 0, "Failed to create event object", -errno);
 }
 
-Connection::LoopExitEventFd::~LoopExitEventFd()
+Connection::EventFd::~EventFd()
 {
     assert(fd >= 0);
     close(fd);
 }
 
-}}
+} // namespace sdbus::internal
 
 namespace sdbus {
 
+std::optional<std::chrono::microseconds> IConnection::PollData::getRelativeTimeout() const
+{
+    constexpr auto zero = std::chrono::microseconds::zero();
+    if (timeout_usec == 0)
+        return zero;
+    else if (timeout_usec == UINT64_MAX)
+        return std::nullopt;
+
+    // We need C so that we use the same clock as the underlying sd-bus lib.
+    // We use POSIX's clock_gettime in favour of std::chrono::steady_clock to ensure this.
+    struct timespec ts{};
+    auto r = clock_gettime(CLOCK_MONOTONIC, &ts);
+    SDBUS_THROW_ERROR_IF(r < 0, "clock_gettime failed: ", -errno);
+    auto now = std::chrono::nanoseconds(ts.tv_nsec) + std::chrono::seconds(ts.tv_sec);
+    auto absTimeout = std::chrono::microseconds(timeout_usec);
+    auto result = std::chrono::duration_cast<std::chrono::microseconds>(absTimeout - now);
+    return std::max(result, zero);
+}
+
+int IConnection::PollData::getPollTimeout() const
+{
+    auto timeout = getRelativeTimeout();
+    return timeout ? static_cast<int>(std::chrono::ceil<std::chrono::milliseconds>(timeout.value()).count()) : -1;
+}
+
+} // namespace sdbus
+
+namespace sdbus::internal {
+
+std::unique_ptr<sdbus::internal::IConnection> createConnection()
+{
+    auto connection = sdbus::createConnection();
+    SCOPE_EXIT{ connection.release(); };
+    auto connectionInternal = dynamic_cast<sdbus::internal::IConnection*>(connection.get());
+    return std::unique_ptr<sdbus::internal::IConnection>(connectionInternal);
+}
+
+std::unique_ptr<sdbus::internal::IConnection> createPseudoConnection()
+{
+    auto interface = std::make_unique<sdbus::internal::SdBus>();
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::pseudo_bus);
+}
+
+} // namespace sdbus::internal
+
+namespace sdbus {
+
+using internal::Connection;
+
 std::unique_ptr<sdbus::IConnection> createConnection()
 {
     return createSystemBusConnection();
@@ -457,12 +629,23 @@ std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name)
     return createSystemBusConnection(name);
 }
 
+std::unique_ptr<sdbus::IConnection> createDefaultBusConnection()
+{
+    auto interface = std::make_unique<sdbus::internal::SdBus>();
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::default_bus);
+}
+
+std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string& name)
+{
+    auto conn = createDefaultBusConnection();
+    conn->requestName(name);
+    return conn;
+}
+
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection()
 {
     auto interface = std::make_unique<sdbus::internal::SdBus>();
-    assert(interface != nullptr);
-    constexpr sdbus::internal::Connection::system_bus_t system_bus;
-    return std::make_unique<sdbus::internal::Connection>(std::move(interface), system_bus);
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::system_bus);
 }
 
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name)
@@ -475,9 +658,7 @@ std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string&
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection()
 {
     auto interface = std::make_unique<sdbus::internal::SdBus>();
-    assert(interface != nullptr);
-    constexpr sdbus::internal::Connection::session_bus_t session_bus;
-    return std::make_unique<sdbus::internal::Connection>(std::move(interface), session_bus);
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::session_bus);
 }
 
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name)
@@ -487,12 +668,17 @@ std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string
     return conn;
 }
 
-std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host)
+std::unique_ptr<sdbus::IConnection> createSessionBusConnectionWithAddress(const std::string &address)
 {
     auto interface = std::make_unique<sdbus::internal::SdBus>();
     assert(interface != nullptr);
-    constexpr sdbus::internal::Connection::remote_system_bus_t remote_system_bus;
-    return std::make_unique<sdbus::internal::Connection>(std::move(interface), remote_system_bus, host);
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::custom_session_bus, address);
 }
 
+std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host)
+{
+    auto interface = std::make_unique<sdbus::internal::SdBus>();
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::remote_system_bus, host);
 }
+
+} // namespace sdbus

src/Connection.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Connection.h
  *
@@ -40,51 +40,66 @@
 #include <atomic>
 #include <mutex>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
-    class Connection
-        : public sdbus::IConnection           // External, public interface
-        , public sdbus::internal::IConnection // Internal, private interface
+    class Connection final
+        : public sdbus::internal::IConnection
     {
     public:
         // Bus type tags
+        struct default_bus_t{};
+        inline static constexpr default_bus_t default_bus{};
         struct system_bus_t{};
+        inline static constexpr system_bus_t system_bus{};
         struct session_bus_t{};
+        inline static constexpr session_bus_t session_bus{};
+        struct custom_session_bus_t{};
+        inline static constexpr custom_session_bus_t custom_session_bus{};
         struct remote_system_bus_t{};
+        inline static constexpr remote_system_bus_t remote_system_bus{};
+        struct pseudo_bus_t{}; // A bus connection that is not really established with D-Bus daemon
+        inline static constexpr pseudo_bus_t pseudo_bus{};
 
+        Connection(std::unique_ptr<ISdBus>&& interface, default_bus_t);
         Connection(std::unique_ptr<ISdBus>&& interface, system_bus_t);
         Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t);
+        Connection(std::unique_ptr<ISdBus>&& interface, custom_session_bus_t, const std::string& address);
         Connection(std::unique_ptr<ISdBus>&& interface, remote_system_bus_t, const std::string& host);
+        Connection(std::unique_ptr<ISdBus>&& interface, pseudo_bus_t);
         ~Connection() override;
 
         void requestName(const std::string& name) override;
         void releaseName(const std::string& name) override;
         std::string getUniqueName() const override;
-        void enterProcessingLoop() override;
-        void enterProcessingLoopAsync() override;
-        void leaveProcessingLoop() override;
-        sdbus::IConnection::PollData getProcessLoopPollData() const override;
+        void enterEventLoop() override;
+        void enterEventLoopAsync() override;
+        void leaveEventLoop() override;
+        PollData getEventLoopPollData() const override;
         bool processPendingRequest() override;
 
         void addObjectManager(const std::string& objectPath) override;
-        SlotPtr addObjectManager(const std::string& objectPath, void* /*dummy*/) override;
+        void addObjectManager(const std::string& objectPath, floating_slot_t) override;
+        Slot addObjectManager(const std::string& objectPath, request_slot_t) override;
 
         void setMethodCallTimeout(uint64_t timeout) override;
         uint64_t getMethodCallTimeout() const override;
 
+        [[nodiscard]] Slot addMatch(const std::string& match, message_handler callback) override;
+        void addMatch(const std::string& match, message_handler callback, floating_slot_t) override;
+
         const ISdBus& getSdBusInterface() const override;
         ISdBus& getSdBusInterface() override;
 
-        SlotPtr addObjectVTable( const std::string& objectPath
-                               , const std::string& interfaceName
-                               , const sd_bus_vtable* vtable
-                               , void* userData ) override;
+        Slot addObjectVTable( const std::string& objectPath
+                            , const std::string& interfaceName
+                            , const sd_bus_vtable* vtable
+                            , void* userData ) override;
 
+        PlainMessage createPlainMessage() const override;
         MethodCall createMethodCall( const std::string& destination
                                    , const std::string& objectPath
                                    , const std::string& interfaceName
                                    , const std::string& methodName ) const override;
-
         Signal createSignal( const std::string& objectPath
                            , const std::string& interfaceName
                            , const std::string& signalName ) const override;
@@ -99,11 +114,12 @@ namespace sdbus { namespace internal {
         void emitInterfacesRemovedSignal( const std::string& objectPath
                                         , const std::vector<std::string>& interfaces ) override;
 
-        SlotPtr registerSignalHandler( const std::string& objectPath
-                                     , const std::string& interfaceName
-                                     , const std::string& signalName
-                                     , sd_bus_message_handler_t callback
-                                     , void* userData ) override;
+        Slot registerSignalHandler( const std::string& sender
+                                  , const std::string& objectPath
+                                  , const std::string& interfaceName
+                                  , const std::string& signalName
+                                  , sd_bus_message_handler_t callback
+                                  , void* userData ) override;
 
         MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) override;
 
@@ -113,21 +129,35 @@ namespace sdbus { namespace internal {
         Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& busFactory);
 
         BusPtr openBus(const std::function<int(sd_bus**)>& busFactory);
+        BusPtr openPseudoBus();
         void finishHandshake(sd_bus* bus);
         bool waitForNextRequest();
-        static std::string composeSignalMatchFilter( const std::string& objectPath
-                                                   , const std::string& interfaceName
-                                                   , const std::string& signalName );
-        void notifyProcessingLoopToExit();
-        void clearExitNotification();
-        void joinWithProcessingLoop();
+        static std::string composeSignalMatchFilter( const std::string &sender
+                                                   , const std::string &objectPath
+                                                   , const std::string &interfaceName
+                                                   , const std::string &signalName);
+        void notifyEventLoop(int fd) const;
+        void notifyEventLoopToExit() const;
+        void clearEventLoopNotification(int fd) const;
+        void notifyEventLoop() const override;
+        void notifyEventLoopNewTimeout() const override;
+
+    private:
+        void joinWithEventLoop();
         static std::vector</*const */char*> to_strv(const std::vector<std::string>& strings);
 
-        struct LoopExitEventFd
+        struct EventFd
         {
-            LoopExitEventFd();
-            ~LoopExitEventFd();
-            int fd;
+            EventFd();
+            ~EventFd();
+            int fd{-1};
+        };
+
+        struct MatchInfo
+        {
+            message_handler callback;
+            Connection& connection;
+            sd_bus_slot *slot;
         };
 
     private:
@@ -136,9 +166,12 @@ namespace sdbus { namespace internal {
         std::thread asyncLoopThread_;
         std::atomic<std::thread::id> loopThreadId_;
         std::mutex loopMutex_;
-        LoopExitEventFd loopExitFd_;
+        EventFd loopExitFd_;
+        EventFd eventFd_;
+        std::atomic<uint64_t> activeTimeout_{};
+        std::vector<Slot> floatingMatchRules_;
     };
 
-}}
+}
 
 #endif /* SDBUS_CXX_INTERNAL_CONNECTION_H_ */

src/Error.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Error.cpp
  *

src/Flags.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Flags.cpp
  *

src/IConnection.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file IConnection.h
  *
@@ -27,6 +27,7 @@
 #ifndef SDBUS_CXX_INTERNAL_ICONNECTION_H_
 #define SDBUS_CXX_INTERNAL_ICONNECTION_H_
 
+#include <sdbus-c++/IConnection.h>
 #include <systemd/sd-bus.h>
 #include <string>
 #include <memory>
@@ -38,34 +39,33 @@ namespace sdbus {
     class MethodCall;
     class MethodReply;
     class Signal;
+    class PlainMessage;
     namespace internal {
         class ISdBus;
     }
 }
 
-namespace sdbus {
-namespace internal {
-
-    using SlotPtr = std::unique_ptr<void, std::function<void(void*)>>;
+namespace sdbus::internal {
 
     class IConnection
+        : public ::sdbus::IConnection
     {
     public:
-        virtual ~IConnection() = default;
+        ~IConnection() override = default;
 
         virtual const ISdBus& getSdBusInterface() const = 0;
         virtual ISdBus& getSdBusInterface() = 0;
 
-        virtual SlotPtr addObjectVTable( const std::string& objectPath
-                                       , const std::string& interfaceName
-                                       , const sd_bus_vtable* vtable
-                                       , void* userData ) = 0;
+        [[nodiscard]] virtual Slot addObjectVTable( const std::string& objectPath
+                                                  , const std::string& interfaceName
+                                                  , const sd_bus_vtable* vtable
+                                                  , void* userData ) = 0;
 
+        virtual PlainMessage createPlainMessage() const = 0;
         virtual MethodCall createMethodCall( const std::string& destination
                                            , const std::string& objectPath
                                            , const std::string& interfaceName
                                            , const std::string& methodName ) const = 0;
-
         virtual Signal createSignal( const std::string& objectPath
                                    , const std::string& interfaceName
                                    , const std::string& signalName ) const = 0;
@@ -80,21 +80,24 @@ namespace internal {
         virtual void emitInterfacesRemovedSignal( const std::string& objectPath
                                                 , const std::vector<std::string>& interfaces ) = 0;
 
-        virtual SlotPtr addObjectManager(const std::string& objectPath, void* /*dummy*/ = nullptr) = 0;
+        using sdbus::IConnection::addObjectManager;
+        [[nodiscard]] virtual Slot addObjectManager(const std::string& objectPath, request_slot_t) = 0;
 
-        virtual SlotPtr registerSignalHandler( const std::string& objectPath
-                                             , const std::string& interfaceName
-                                             , const std::string& signalName
-                                             , sd_bus_message_handler_t callback
-                                             , void* userData ) = 0;
-
-        virtual void enterProcessingLoopAsync() = 0;
-        virtual void leaveProcessingLoop() = 0;
+        [[nodiscard]] virtual Slot registerSignalHandler( const std::string& sender
+                                                        , const std::string& objectPath
+                                                        , const std::string& interfaceName
+                                                        , const std::string& signalName
+                                                        , sd_bus_message_handler_t callback
+                                                        , void* userData ) = 0;
 
+        virtual void notifyEventLoop() const = 0;
+        virtual void notifyEventLoopNewTimeout() const = 0;
         virtual MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) = 0;
     };
 
-}
+    [[nodiscard]] std::unique_ptr<sdbus::internal::IConnection> createConnection();
+    [[nodiscard]] std::unique_ptr<sdbus::internal::IConnection> createPseudoConnection();
+
 }
 
 #endif /* SDBUS_CXX_INTERNAL_ICONNECTION_H_ */

src/ISdBus.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file ISdBus.h
  * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@@ -30,7 +30,7 @@
 
 #include <systemd/sd-bus.h>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
     class ISdBus
     {
@@ -51,6 +51,7 @@ namespace sdbus { namespace internal {
         virtual int sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *ret_error, sd_bus_message **reply) = 0;
         virtual int sd_bus_call_async(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m, sd_bus_message_handler_t callback, void *userdata, uint64_t usec) = 0;
 
+        virtual int sd_bus_message_new(sd_bus *bus, sd_bus_message **m, uint8_t type) = 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 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_message_new_method_return(sd_bus_message *call, sd_bus_message **m) = 0;
@@ -65,8 +66,10 @@ namespace sdbus { namespace internal {
         virtual int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces) = 0;
         virtual int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces) = 0;
 
-        virtual int sd_bus_open_user(sd_bus **ret) = 0;
+        virtual int sd_bus_open(sd_bus **ret) = 0;
         virtual int sd_bus_open_system(sd_bus **ret) = 0;
+        virtual int sd_bus_open_user(sd_bus **ret) = 0;
+        virtual int sd_bus_open_user_with_address(sd_bus **ret, const char* address) = 0;
         virtual int sd_bus_open_system_remote(sd_bus **ret, const char* host) = 0;
         virtual int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) = 0;
         virtual int sd_bus_release_name(sd_bus *bus, const char *name) = 0;
@@ -76,13 +79,30 @@ namespace sdbus { namespace internal {
         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 sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) = 0;
 
+        virtual int sd_bus_new(sd_bus **ret) = 0;
+        virtual int sd_bus_start(sd_bus *bus) = 0;
+
         virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) = 0;
         virtual int sd_bus_get_poll_data(sd_bus *bus, PollData* data) = 0;
 
         virtual int sd_bus_flush(sd_bus *bus) = 0;
         virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) = 0;
+        virtual sd_bus *sd_bus_close_unref(sd_bus *bus) = 0;
+
+        virtual int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) = 0;
+
+        virtual int sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **c) = 0;
+        virtual sd_bus_creds* sd_bus_creds_unref(sd_bus_creds *c) = 0;
+
+        virtual int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid) = 0;
+        virtual int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid) = 0;
+        virtual int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *uid) = 0;
+        virtual int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid) = 0;
+        virtual int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *egid) = 0;
+        virtual int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids) = 0;
+        virtual int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **label) = 0;
     };
 
-}}
+}
 
 #endif //SDBUS_CXX_ISDBUS_H

src/Message.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Message.cpp
  *
@@ -28,7 +28,8 @@
 #include <sdbus-c++/Types.h>
 #include <sdbus-c++/Error.h>
 #include "MessageUtils.h"
-#include "SdBus.h"
+#include "ISdBus.h"
+#include "IConnection.h"
 #include "ScopeGuard.h"
 #include <systemd/sd-bus.h>
 #include <cassert>
@@ -582,12 +583,14 @@ void Message::rewind(bool complete)
 
 std::string Message::getInterfaceName() const
 {
-    return sd_bus_message_get_interface((sd_bus_message*)msg_);
+    auto interface = sd_bus_message_get_interface((sd_bus_message*)msg_);
+    return interface != nullptr ? interface : "";
 }
 
 std::string Message::getMemberName() const
 {
-    return sd_bus_message_get_member((sd_bus_message*)msg_);
+    auto member = sd_bus_message_get_member((sd_bus_message*)msg_);
+    return member != nullptr ? member : "";
 }
 
 std::string Message::getSender() const
@@ -595,6 +598,18 @@ std::string Message::getSender() const
     return sd_bus_message_get_sender((sd_bus_message*)msg_);
 }
 
+std::string Message::getPath() const
+{
+    auto path = sd_bus_message_get_path((sd_bus_message*)msg_);
+    return path != nullptr ? path : "";
+}
+
+std::string Message::getDestination() const
+{
+    auto destination = sd_bus_message_get_destination((sd_bus_message*)msg_);
+    return destination != nullptr ? destination : "";
+}
+
 void Message::peekType(std::string& type, std::string& contents) const
 {
     char typeSig;
@@ -602,7 +617,7 @@ void Message::peekType(std::string& type, std::string& contents) const
     auto r = sd_bus_message_peek_type((sd_bus_message*)msg_, &typeSig, &contentsSig);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to peek message type", -r);
     type = typeSig;
-    contents = contentsSig;
+    contents = contentsSig ? contentsSig : "";
 }
 
 bool Message::isValid() const
@@ -615,6 +630,124 @@ bool Message::isEmpty() const
     return sd_bus_message_is_empty((sd_bus_message*)msg_) != 0;
 }
 
+pid_t Message::getCredsPid() const
+{
+    uint64_t mask = SD_BUS_CREDS_PID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    pid_t pid = 0;
+    r = sdbus_->sd_bus_creds_get_pid(creds, &pid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred pid", -r);
+    return pid;
+}
+
+uid_t Message::getCredsUid() const
+{
+    uint64_t mask = SD_BUS_CREDS_UID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    uid_t uid = (uid_t)-1;
+    r = sdbus_->sd_bus_creds_get_uid(creds, &uid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred uid", -r);
+    return uid;
+}
+
+uid_t Message::getCredsEuid() const
+{
+    uint64_t mask = SD_BUS_CREDS_EUID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    uid_t euid = (uid_t)-1;
+    r = sdbus_->sd_bus_creds_get_euid(creds, &euid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred euid", -r);
+    return euid;
+}
+
+gid_t Message::getCredsGid() const
+{
+    uint64_t mask = SD_BUS_CREDS_GID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    gid_t gid = (gid_t)-1;
+    r = sdbus_->sd_bus_creds_get_gid(creds, &gid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred gid", -r);
+    return gid;
+}
+
+gid_t Message::getCredsEgid() const
+{
+    uint64_t mask = SD_BUS_CREDS_EGID | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    gid_t egid = (gid_t)-1;
+    r = sdbus_->sd_bus_creds_get_egid(creds, &egid);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred egid", -r);
+    return egid;
+}
+
+std::vector<gid_t> Message::getCredsSupplementaryGids() const
+{
+    uint64_t mask = SD_BUS_CREDS_SUPPLEMENTARY_GIDS | SD_BUS_CREDS_AUGMENT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    const gid_t *cGids = nullptr;
+    r = sdbus_->sd_bus_creds_get_supplementary_gids(creds, &cGids);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred supplementary gids", -r);
+
+    std::vector<gid_t> gids{};
+    if (cGids != nullptr)
+    {
+        for (int i = 0; i < r; i++)
+            gids.push_back(cGids[i]);
+    }
+
+    return gids;
+}
+
+std::string Message::getSELinuxContext() const
+{
+    uint64_t mask = SD_BUS_CREDS_AUGMENT | SD_BUS_CREDS_SELINUX_CONTEXT;
+    sd_bus_creds *creds = nullptr;
+    SCOPE_EXIT{ sdbus_->sd_bus_creds_unref(creds); };
+    int r = sdbus_->sd_bus_query_sender_creds((sd_bus_message*)msg_, mask, &creds);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus creds", -r);
+
+    const char *cLabel = nullptr;
+    r = sdbus_->sd_bus_creds_get_selinux_context(creds, &cLabel);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus cred selinux context", -r);
+    return cLabel;
+}
+
+
+MethodCall::MethodCall( void *msg
+                      , internal::ISdBus *sdbus
+                      , const internal::IConnection *connection
+                      , adopt_message_t) noexcept
+   : Message(msg, sdbus, adopt_message)
+   , connection_(connection)
+{
+    assert(connection_ != nullptr);
+}
+
 void MethodCall::dontExpectReply()
 {
     auto r = sd_bus_message_set_expect_reply((sd_bus_message*)msg_, 0);
@@ -649,6 +782,10 @@ MethodReply MethodCall::sendWithReply(uint64_t timeout) const
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
 
+    // Force event loop to re-enter processing to handle queued messages
+    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
+    connection_->notifyEventLoop();
+
     return Factory::create<MethodReply>(sdbusReply, sdbus_, adopt_message);
 }
 
@@ -657,23 +794,40 @@ MethodReply MethodCall::sendWithNoReply() const
     auto r = sdbus_->sd_bus_send(nullptr, (sd_bus_message*)msg_, nullptr);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method with no reply", -r);
 
+    // Force event loop to re-enter processing to handle queued messages
+    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
+    connection_->notifyEventLoop();
+
     return Factory::create<MethodReply>(); // No reply
 }
 
 void MethodCall::send(void* callback, void* userData, uint64_t timeout, dont_request_slot_t) const
 {
-    auto r = sdbus_->sd_bus_call_async(nullptr, nullptr, (sd_bus_message*)msg_, (sd_bus_message_handler_t)callback, userData, timeout);
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
+    MethodCall::send(callback, userData, timeout, floating_slot);
 }
 
-MethodCall::Slot MethodCall::send(void* callback, void* userData, uint64_t timeout) const
+void MethodCall::send(void* callback, void* userData, uint64_t timeout, floating_slot_t) const
+{
+    auto r = sdbus_->sd_bus_call_async(nullptr, nullptr, (sd_bus_message*)msg_, (sd_bus_message_handler_t)callback, userData, timeout);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
+
+    // Force event loop to re-enter polling with the async call timeout if that is less than the one used in current poll
+    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
+    connection_->notifyEventLoopNewTimeout();
+}
+
+Slot MethodCall::send(void* callback, void* userData, uint64_t timeout) const
 {
     sd_bus_slot* slot;
 
     auto r = sdbus_->sd_bus_call_async(nullptr, &slot, (sd_bus_message*)msg_, (sd_bus_message_handler_t)callback, userData, timeout);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method asynchronously", -r);
 
-    return Slot{slot, [sdbus_ = sdbus_](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
+    // Force event loop to re-enter polling with the async call timeout if that is less than the one used in current poll
+    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
+    connection_->notifyEventLoopNewTimeout();
+
+    return {slot, [sdbus_ = sdbus_](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }
 
 MethodReply MethodCall::createReply() const
@@ -710,62 +864,21 @@ void Signal::send() const
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit signal", -r);
 }
 
+void Signal::setDestination(const std::string& destination)
+{
+    auto r = sdbus_->sd_bus_message_set_destination((sd_bus_message*)msg_, destination.c_str());
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set signal destination", -r);
+}
+
 PlainMessage createPlainMessage()
 {
-    int r;
-
-    // All references to the bus (like created messages) must not outlive this thread (because messages refer to sdbus
-    // which is thread-local, and because BusReferenceKeeper below destroys the bus at thread exit).
-    // A more flexible solution would be that the caller would already provide an ISdBus reference as a parameter.
-    // Variant is one of the callers. This means Variant could no more be created in a stand-alone way, but
-    // through a factory of some existing facility (Object, Proxy, Connection...).
-    // TODO: Consider this alternative of creating Variant, it may live next to the current one. This function would
-    // get IConnection* parameter and IConnection would provide createPlainMessage factory (just like it already
-    // provides e.g. createMethodCall). If this parameter were null, the current mechanism would be used.
-
-    thread_local internal::SdBus sdbus;
-
-    sd_bus* bus{};
-    SCOPE_EXIT{ sd_bus_unref(bus); };
-    r = sd_bus_default_system(&bus);
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get default system bus", -r);
-
-    thread_local struct BusReferenceKeeper
-    {
-        explicit BusReferenceKeeper(sd_bus* bus) : bus_(sd_bus_ref(bus)) { sd_bus_flush(bus_); }
-        ~BusReferenceKeeper() { sd_bus_flush_close_unref(bus_); }
-        sd_bus* bus_{};
-    } busReferenceKeeper{bus};
-
-//    thread_local struct BusKeeper
-//    {
-//        BusKeeper()
-//        {
-//            auto r = sd_bus_open_system(&bus);
-//            sd_bus_flush(bus);
-//            SDBUS_THROW_ERROR_IF(r < 0, "Failed to get default system bus", -r);
-//        }
-
-//        ~BusKeeper()
-//        {
-//            sd_bus_flush_close_unref(bus);
-//        }
-
-//        sd_bus* bus{};
-//        internal::SdBus intf;
-//    } busKeeper;
-
-    // Shelved here as handy thing for potential future tracing purposes:
-    //#include <unistd.h>
-    //#include <sys/syscall.h>
-    //#define gettid() syscall(SYS_gettid)
-    //printf("createPlainMessage: sd_bus*=[%p], n_ref=[%d], TID=[%d]\n", bus, *(unsigned*)bus, gettid());
-
-    sd_bus_message* sdbusMsg{};
-    r = sd_bus_message_new(bus, &sdbusMsg, _SD_BUS_MESSAGE_TYPE_INVALID);
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create a new message", -r);
-
-    return Message::Factory::create<PlainMessage>(sdbusMsg, &sdbus, adopt_message);
+    //static auto connection = internal::createConnection();
+    // Let's create a pseudo connection -- one that does not really connect to the real bus.
+    // This is a bit of a hack, but it enables use to work with D-Bus message locally without
+    // the need of D-Bus daemon. This is especially useful in unit tests of both sdbus-c++ and client code.
+    // Additionally, it's light-weight and fast solution.
+    static auto connection = internal::createPseudoConnection();
+    return connection->createPlainMessage();
 }
 
 }

src/MessageUtils.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file MessageUtils.h
  *
@@ -57,6 +57,12 @@ namespace sdbus
         {
             return _Msg{msg, sdbus, adopt_message};
         }
+
+        template<typename _Msg>
+        static _Msg create(void *msg, internal::ISdBus* sdbus, const internal::IConnection* connection, adopt_message_t)
+        {
+            return _Msg{msg, sdbus, connection, adopt_message};
+        }
     };
 
     PlainMessage createPlainMessage();

src/Object.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Object.cpp
  *
@@ -31,83 +31,128 @@
 #include <sdbus-c++/Error.h>
 #include <sdbus-c++/MethodResult.h>
 #include <sdbus-c++/Flags.h>
+#include "ScopeGuard.h"
 #include "IConnection.h"
+#include "Utils.h"
 #include "VTableUtils.h"
 #include <systemd/sd-bus.h>
 #include <utility>
 #include <cassert>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 Object::Object(sdbus::internal::IConnection& connection, std::string objectPath)
     : connection_(connection), objectPath_(std::move(objectPath))
 {
+    SDBUS_CHECK_OBJECT_PATH(objectPath_);
 }
 
 void Object::registerMethod( const std::string& interfaceName
-                           , const std::string& methodName
-                           , const std::string& inputSignature
-                           , const std::string& outputSignature
+                           , std::string methodName
+                           , std::string inputSignature
+                           , std::string outputSignature
                            , method_callback methodCallback
                            , Flags flags )
 {
+    registerMethod( interfaceName
+                  , std::move(methodName)
+                  , std::move(inputSignature)
+                  , {}
+                  , std::move(outputSignature)
+                  , {}
+                  , std::move(methodCallback)
+                  , std::move(flags) );
+}
+
+void Object::registerMethod( const std::string& interfaceName
+                           , std::string methodName
+                           , std::string inputSignature
+                           , const std::vector<std::string>& inputNames
+                           , std::string outputSignature
+                           , const std::vector<std::string>& outputNames
+                           , method_callback methodCallback
+                           , Flags flags )
+{
+    SDBUS_CHECK_INTERFACE_NAME(interfaceName);
+    SDBUS_CHECK_MEMBER_NAME(methodName);
     SDBUS_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);
 
-    auto& interface = interfaces_[interfaceName];
-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(methodCallback), flags};
-    auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
+    auto& interface = getInterface(interfaceName);
+    InterfaceData::MethodData methodData{ std::move(inputSignature)
+                                        , std::move(outputSignature)
+                                        , paramNamesToString(inputNames) + paramNamesToString(outputNames)
+                                        , std::move(methodCallback)
+                                        , std::move(flags) };
+    auto inserted = interface.methods.emplace(std::move(methodName), std::move(methodData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
 }
 
 void Object::registerSignal( const std::string& interfaceName
-                           , const std::string& signalName
-                           , const std::string& signature
+                           , std::string signalName
+                           , std::string signature
                            , Flags flags )
 {
-    auto& interface = interfaces_[interfaceName];
+    registerSignal(interfaceName, std::move(signalName), std::move(signature), {}, std::move(flags));
+}
 
-    InterfaceData::SignalData signalData{signature, flags};
-    auto inserted = interface.signals_.emplace(signalName, std::move(signalData)).second;
+void Object::registerSignal( const std::string& interfaceName
+                           , std::string signalName
+                           , std::string signature
+                           , const std::vector<std::string>& paramNames
+                           , Flags flags )
+{
+    SDBUS_CHECK_INTERFACE_NAME(interfaceName);
+    SDBUS_CHECK_MEMBER_NAME(signalName);
+
+    auto& interface = getInterface(interfaceName);
+
+    InterfaceData::SignalData signalData{std::move(signature), paramNamesToString(paramNames), std::move(flags)};
+    auto inserted = interface.signals.emplace(std::move(signalName), std::move(signalData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register signal: signal already exists", EINVAL);
 }
 
 void Object::registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
+                             , std::string propertyName
+                             , std::string signature
                              , property_get_callback getCallback
                              , Flags flags )
 {
     registerProperty( interfaceName
-                    , propertyName
-                    , signature
-                    , getCallback
-                    , property_set_callback{}
-                    , flags );
+                    , std::move(propertyName)
+                    , std::move(signature)
+                    , std::move(getCallback)
+                    , {}
+                    , std::move(flags) );
 }
 
 void Object::registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
+                             , std::string propertyName
+                             , std::string signature
                              , property_get_callback getCallback
                              , property_set_callback setCallback
                              , Flags flags )
 {
+    SDBUS_CHECK_INTERFACE_NAME(interfaceName);
+    SDBUS_CHECK_MEMBER_NAME(propertyName);
     SDBUS_THROW_ERROR_IF(!getCallback && !setCallback, "Invalid property callbacks provided", EINVAL);
 
-    auto& interface = interfaces_[interfaceName];
+    auto& interface = getInterface(interfaceName);
 
-    InterfaceData::PropertyData propertyData{signature, std::move(getCallback), std::move(setCallback), flags};
-    auto inserted = interface.properties_.emplace(propertyName, std::move(propertyData)).second;
+    InterfaceData::PropertyData propertyData{ std::move(signature)
+                                            , std::move(getCallback)
+                                            , std::move(setCallback)
+                                            , std::move(flags) };
+    auto inserted = interface.properties.emplace(std::move(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;
+    auto& interface = getInterface(interfaceName);
+    interface.flags = flags;
 }
 
 void Object::finishRegistration()
@@ -172,7 +217,7 @@ void Object::emitInterfacesRemovedSignal(const std::vector<std::string>& interfa
 
 void Object::addObjectManager()
 {
-    objectManagerSlot_ = connection_.addObjectManager(objectPath_);
+    objectManagerSlot_ = connection_.addObjectManager(objectPath_, request_slot);
 }
 
 void Object::removeObjectManager()
@@ -187,15 +232,30 @@ bool Object::hasObjectManager() const
 
 sdbus::IConnection& Object::getConnection() const
 {
-    return dynamic_cast<sdbus::IConnection&>(connection_);
+    return connection_;
+}
+
+const std::string& Object::getObjectPath() const
+{
+    return objectPath_;
+}
+
+const Message* Object::getCurrentlyProcessedMessage() const
+{
+    return m_CurrentlyProcessedMessage.load(std::memory_order_relaxed);
+}
+
+Object::InterfaceData& Object::getInterface(const std::string& interfaceName)
+{
+    return interfaces_.emplace(interfaceName, *this).first->second;
 }
 
 const std::vector<sd_bus_vtable>& Object::createInterfaceVTable(InterfaceData& interfaceData)
 {
-    auto& vtable = interfaceData.vtable_;
+    auto& vtable = interfaceData.vtable;
     assert(vtable.empty());
 
-    vtable.push_back(createVTableStartItem(interfaceData.flags_.toSdBusInterfaceFlags()));
+    vtable.push_back(createVTableStartItem(interfaceData.flags.toSdBusInterfaceFlags()));
     registerMethodsToVTable(interfaceData, vtable);
     registerSignalsToVTable(interfaceData, vtable);
     registerPropertiesToVTable(interfaceData, vtable);
@@ -206,50 +266,52 @@ const std::vector<sd_bus_vtable>& Object::createInterfaceVTable(InterfaceData& i
 
 void Object::registerMethodsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
 {
-    for (const auto& item : interfaceData.methods_)
+    for (const auto& item : interfaceData.methods)
     {
         const auto& methodName = item.first;
         const auto& methodData = item.second;
 
         vtable.push_back(createVTableMethodItem( methodName.c_str()
-                                               , methodData.inputArgs_.c_str()
-                                               , methodData.outputArgs_.c_str()
+                                               , methodData.inputArgs.c_str()
+                                               , methodData.outputArgs.c_str()
+                                               , methodData.paramNames.c_str()
                                                , &Object::sdbus_method_callback
-                                               , methodData.flags_.toSdBusMethodFlags() ));
+                                               , methodData.flags.toSdBusMethodFlags() ));
     }
 }
 
 void Object::registerSignalsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
 {
-    for (const auto& item : interfaceData.signals_)
+    for (const auto& item : interfaceData.signals)
     {
         const auto& signalName = item.first;
         const auto& signalData = item.second;
 
         vtable.push_back(createVTableSignalItem( signalName.c_str()
-                                               , signalData.signature_.c_str()
-                                               , signalData.flags_.toSdBusSignalFlags() ));
+                                               , signalData.signature.c_str()
+                                               , signalData.paramNames.c_str()
+                                               , signalData.flags.toSdBusSignalFlags() ));
     }
 }
 
 void Object::registerPropertiesToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
 {
-    for (const auto& item : interfaceData.properties_)
+    for (const auto& item : interfaceData.properties)
     {
         const auto& propertyName = item.first;
         const auto& propertyData = item.second;
 
-        if (!propertyData.setCallback_)
+        if (!propertyData.setCallback)
             vtable.push_back(createVTablePropertyItem( propertyName.c_str()
-                                                     , propertyData.signature_.c_str()
+                                                     , propertyData.signature.c_str()
                                                      , &Object::sdbus_property_get_callback
-                                                     , propertyData.flags_.toSdBusPropertyFlags() ));
+                                                     , propertyData.flags.toSdBusPropertyFlags() ));
         else
             vtable.push_back(createVTableWritablePropertyItem( propertyName.c_str()
-                                                             , propertyData.signature_.c_str()
+                                                             , propertyData.signature.c_str()
                                                              , &Object::sdbus_property_get_callback
                                                              , &Object::sdbus_property_set_callback
-                                                             , propertyData.flags_.toSdBusWritablePropertyFlags() ));
+                                                             , propertyData.flags.toSdBusWritablePropertyFlags() ));
     }
 }
 
@@ -257,25 +319,39 @@ void Object::activateInterfaceVTable( const std::string& interfaceName
                                     , InterfaceData& interfaceData
                                     , const std::vector<sd_bus_vtable>& vtable )
 {
-    interfaceData.slot_ = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
+    interfaceData.slot = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], &interfaceData);
+}
+
+std::string Object::paramNamesToString(const std::vector<std::string>& paramNames)
+{
+    std::string names;
+    for (const auto& name : paramNames)
+        names += name + '\0';
+    return names;
 }
 
 int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
 {
-    auto* object = static_cast<Object*>(userData);
-    assert(object != nullptr);
+    auto* interfaceData = static_cast<InterfaceData*>(userData);
+    assert(interfaceData != nullptr);
+    auto& object = interfaceData->object;
 
-    auto message = Message::Factory::create<MethodCall>(sdbusMessage, &object->connection_.getSdBusInterface());
+    auto message = Message::Factory::create<MethodCall>(sdbusMessage, &object.connection_.getSdBusInterface());
 
-    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[message.getInterfaceName()].methods_[message.getMemberName()].callback_;
+    object.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
+    SCOPE_EXIT
+    {
+        object.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
+    };
+
+    auto& callback = interfaceData->methods[message.getMemberName()].callback;
     assert(callback);
 
     try
     {
-        callback(std::move(message));
+        callback(message);
     }
-    catch (const sdbus::Error& e)
+    catch (const Error& e)
     {
         sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
     }
@@ -285,17 +361,17 @@ int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData,
 
 int Object::sdbus_property_get_callback( sd_bus */*bus*/
                                        , const char */*objectPath*/
-                                       , const char *interface
+                                       , const char */*interface*/
                                        , const char *property
                                        , sd_bus_message *sdbusReply
                                        , void *userData
                                        , sd_bus_error *retError )
 {
-    auto* object = static_cast<Object*>(userData);
-    assert(object != nullptr);
+    auto* interfaceData = static_cast<InterfaceData*>(userData);
+    assert(interfaceData != nullptr);
+    auto& object = interfaceData->object;
 
-    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[interface].properties_[property].getCallback_;
+    auto& callback = interfaceData->properties[property].getCallback;
     // Getter can be empty - the case of "write-only" property
     if (!callback)
     {
@@ -303,13 +379,13 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/
         return 1;
     }
 
-    auto reply = Message::Factory::create<PropertyGetReply>(sdbusReply, &object->connection_.getSdBusInterface());
+    auto reply = Message::Factory::create<PropertyGetReply>(sdbusReply, &object.connection_.getSdBusInterface());
 
     try
     {
         callback(reply);
     }
-    catch (const sdbus::Error& e)
+    catch (const Error& e)
     {
         sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
     }
@@ -319,26 +395,32 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/
 
 int Object::sdbus_property_set_callback( sd_bus */*bus*/
                                        , const char */*objectPath*/
-                                       , const char *interface
+                                       , const char */*interface*/
                                        , const char *property
                                        , sd_bus_message *sdbusValue
                                        , void *userData
                                        , sd_bus_error *retError )
 {
-    auto* object = static_cast<Object*>(userData);
-    assert(object != nullptr);
+    auto* interfaceData = static_cast<InterfaceData*>(userData);
+    assert(interfaceData != nullptr);
+    auto& object = interfaceData->object;
 
-    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[interface].properties_[property].setCallback_;
+    auto& callback = interfaceData->properties[property].setCallback;
     assert(callback);
 
-    auto value = Message::Factory::create<PropertySetCall>(sdbusValue, &object->connection_.getSdBusInterface());
+    auto value = Message::Factory::create<PropertySetCall>(sdbusValue, &object.connection_.getSdBusInterface());
+
+    object.m_CurrentlyProcessedMessage.store(&value, std::memory_order_relaxed);
+    SCOPE_EXIT
+    {
+        object.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
+    };
 
     try
     {
         callback(value);
     }
-    catch (const sdbus::Error& e)
+    catch (const Error& e)
     {
         sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
     }
@@ -346,7 +428,7 @@ int Object::sdbus_property_set_callback( sd_bus */*bus*/
     return 1;
 }
 
-}}
+}
 
 namespace sdbus {
 

src/Object.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Object.h
  *
@@ -35,10 +35,10 @@
 #include <vector>
 #include <functional>
 #include <memory>
+#include <atomic>
 #include <cassert>
 
-namespace sdbus {
-namespace internal {
+namespace sdbus::internal {
 
     class Object
         : public IObject
@@ -47,26 +47,38 @@ namespace internal {
         Object(sdbus::internal::IConnection& connection, std::string objectPath);
 
         void registerMethod( const std::string& interfaceName
-                           , const std::string& methodName
-                           , const std::string& inputSignature
-                           , const std::string& outputSignature
+                           , std::string methodName
+                           , std::string inputSignature
+                           , std::string outputSignature
+                           , method_callback methodCallback
+                           , Flags flags ) override;
+        void registerMethod( const std::string& interfaceName
+                           , std::string methodName
+                           , std::string inputSignature
+                           , const std::vector<std::string>& inputNames
+                           , std::string outputSignature
+                           , const std::vector<std::string>& outputNames
                            , method_callback methodCallback
                            , Flags flags ) override;
 
         void registerSignal( const std::string& interfaceName
-                           , const std::string& signalName
-                           , const std::string& signature
+                           , std::string signalName
+                           , std::string signature
+                           , Flags flags ) override;
+        void registerSignal( const std::string& interfaceName
+                           , std::string signalName
+                           , std::string signature
+                           , const std::vector<std::string>& paramNames
                            , Flags flags ) override;
 
         void registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
+                             , std::string propertyName
+                             , std::string signature
                              , property_get_callback getCallback
                              , Flags flags ) override;
-
         void registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
+                             , std::string propertyName
+                             , std::string signature
                              , property_get_callback getCallback
                              , property_set_callback setCallback
                              , Flags flags ) override;
@@ -90,42 +102,52 @@ namespace internal {
         bool hasObjectManager() const override;
 
         sdbus::IConnection& getConnection() const override;
+        const std::string& getObjectPath() const override;
+        const Message* getCurrentlyProcessedMessage() const override;
 
     private:
         using InterfaceName = std::string;
         struct InterfaceData
         {
+            InterfaceData(Object& object) : object(object) {}
+
             using MethodName = std::string;
             struct MethodData
             {
-                std::string inputArgs_;
-                std::string outputArgs_;
-                method_callback callback_;
-                Flags flags_;
+                const std::string inputArgs;
+                const std::string outputArgs;
+                const std::string paramNames;
+                method_callback callback;
+                Flags flags;
             };
-            std::map<MethodName, MethodData> methods_;
+            std::map<MethodName, MethodData> methods;
             using SignalName = std::string;
             struct SignalData
             {
-                std::string signature_;
-                Flags flags_;
+                const std::string signature;
+                const std::string paramNames;
+                Flags flags;
             };
-            std::map<SignalName, SignalData> signals_;
+            std::map<SignalName, SignalData> signals;
             using PropertyName = std::string;
             struct PropertyData
             {
-                std::string signature_;
-                property_get_callback getCallback_;
-                property_set_callback setCallback_;
-                Flags flags_;
+                const 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::map<PropertyName, PropertyData> properties;
+            std::vector<sd_bus_vtable> vtable;
+            Flags flags;
+            Object& object;
 
-            SlotPtr slot_;
+            // This is intentionally the last member, because it must be destructed first,
+            // releasing callbacks above before the callbacks themselves are destructed.
+            Slot slot;
         };
 
+        InterfaceData& getInterface(const std::string& interfaceName);
         static const std::vector<sd_bus_vtable>& createInterfaceVTable(InterfaceData& interfaceData);
         static void registerMethodsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable);
         static void registerSignalsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable);
@@ -133,6 +155,7 @@ namespace internal {
         void activateInterfaceVTable( const std::string& interfaceName
                                     , InterfaceData& interfaceData
                                     , const std::vector<sd_bus_vtable>& vtable );
+        static std::string paramNamesToString(const std::vector<std::string>& paramNames);
 
         static int sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
         static int sdbus_property_get_callback( sd_bus *bus
@@ -154,10 +177,10 @@ namespace internal {
         sdbus::internal::IConnection& connection_;
         std::string objectPath_;
         std::map<InterfaceName, InterfaceData> interfaces_;
-        SlotPtr objectManagerSlot_;
+        Slot objectManagerSlot_;
+        std::atomic<const Message*> m_CurrentlyProcessedMessage{nullptr};
     };
 
 }
-}
 
 #endif /* SDBUS_CXX_INTERNAL_OBJECT_H_ */

src/Proxy.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Proxy.cpp
  *
@@ -27,6 +27,7 @@
 #include "Proxy.h"
 #include "IConnection.h"
 #include "MessageUtils.h"
+#include "Utils.h"
 #include "sdbus-c++/Message.h"
 #include "sdbus-c++/IConnection.h"
 #include "sdbus-c++/Error.h"
@@ -34,15 +35,18 @@
 #include <systemd/sd-bus.h>
 #include <cassert>
 #include <chrono>
-#include <thread>
+#include <utility>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 Proxy::Proxy(sdbus::internal::IConnection& connection, std::string destination, std::string objectPath)
     : connection_(&connection, [](sdbus::internal::IConnection *){ /* Intentionally left empty */ })
     , destination_(std::move(destination))
     , objectPath_(std::move(objectPath))
 {
+    SDBUS_CHECK_SERVICE_NAME(destination_);
+    SDBUS_CHECK_OBJECT_PATH(objectPath_);
+
     // The connection is not ours only, it is owned and managed by the user and we just reference
     // it here, so we expect the client to manage the event loop upon this connection themselves.
 }
@@ -54,9 +58,12 @@ Proxy::Proxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
     , destination_(std::move(destination))
     , objectPath_(std::move(objectPath))
 {
+    SDBUS_CHECK_SERVICE_NAME(destination_);
+    SDBUS_CHECK_OBJECT_PATH(objectPath_);
+
     // The connection is ours only, i.e. it's us who has to manage the event loop upon this connection,
     // in order that we get and process signals, async call replies, and other messages from D-Bus.
-    connection_->enterProcessingLoopAsync();
+    connection_->enterEventLoopAsync();
 }
 
 MethodCall Proxy::createMethodCall(const std::string& interfaceName, const std::string& methodName)
@@ -67,14 +74,14 @@ MethodCall Proxy::createMethodCall(const std::string& interfaceName, const std::
 MethodReply Proxy::callMethod(const MethodCall& message, uint64_t timeout)
 {
     // Sending method call synchronously is the only operation that blocks, waiting for the method
-    // reply message among the incoming message on the sd-bus connection socket. But typically there
+    // reply message among the incoming messages on the sd-bus connection socket. But typically there
     // already is somebody that generally handles incoming D-Bus messages -- the connection event loop
     // running typically in its own thread. We have to avoid polling on socket from several threads.
     // So we have to branch here: either we are within the context of the event loop thread, then we
     // can send the message simply via sd_bus_call, which blocks. Or we are in another thread, then
     // we can perform the send operation of the method call message from here (because that is thread-
     // safe like other sd-bus API accesses), but the incoming reply we have to get through the event
-    // loop thread, because this is be the only rightful listener on the sd-bus connection socket.
+    // loop thread, because this is the only rightful listener on the sd-bus connection socket.
     // So, technically, we use async means to wait here for reply received by the event loop thread.
 
     SDBUS_THROW_ERROR_IF(!message.isValid(), "Invalid method call message provided", EINVAL);
@@ -93,16 +100,20 @@ MethodReply Proxy::callMethod(const MethodCall& message, uint64_t timeout)
     return sendMethodCallMessageAndWaitForReply(message, timeout);
 }
 
-void Proxy::callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout)
+PendingAsyncCall Proxy::callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout)
 {
     SDBUS_THROW_ERROR_IF(!message.isValid(), "Invalid async method call message provided", EINVAL);
 
     auto callback = (void*)&Proxy::sdbus_async_reply_handler;
-    auto callData = std::make_unique<AsyncCalls::CallData>(AsyncCalls::CallData{*this, std::move(asyncReplyCallback), {}});
+    auto callData = std::make_shared<AsyncCalls::CallData>(AsyncCalls::CallData{*this, std::move(asyncReplyCallback), {}});
+    auto weakData = std::weak_ptr<AsyncCalls::CallData>{callData};
 
     callData->slot = message.send(callback, callData.get(), timeout);
 
-    pendingAsyncCalls_.addCall(callData->slot.get(), std::move(callData));
+    auto slotPtr = callData->slot.get();
+    pendingAsyncCalls_.addCall(slotPtr, std::move(callData));
+
+    return {weakData};
 }
 
 MethodReply Proxy::sendMethodCallMessageAndWaitForReply(const MethodCall& message, uint64_t timeout)
@@ -116,15 +127,15 @@ MethodReply Proxy::sendMethodCallMessageAndWaitForReply(const MethodCall& messag
     auto callback = (void*)&Proxy::sdbus_async_reply_handler;
     AsyncCalls::CallData callData{*this, std::move(asyncReplyCallback), {}};
 
-    message.send(callback, &callData, timeout, dont_request_slot);
+    message.send(callback, &callData, timeout, floating_slot);
 
     return syncCallReplyData.waitForMethodReply();
 }
 
 void Proxy::SyncCallReplyData::sendMethodReplyToWaitingThread(MethodReply& reply, const Error* error)
 {
-    SCOPE_EXIT{ cond_.notify_one(); };
-    std::unique_lock<std::mutex> lock{mutex_};
+    std::unique_lock lock{mutex_};
+    SCOPE_EXIT{ cond_.notify_one(); }; // This must happen before unlocking the mutex to avoid potential data race on spurious wakeup in the waiting thread
     SCOPE_EXIT{ arrived_ = true; };
 
     //error_ = nullptr; // Necessary if SyncCallReplyData instance is thread_local
@@ -137,7 +148,7 @@ void Proxy::SyncCallReplyData::sendMethodReplyToWaitingThread(MethodReply& reply
 
 MethodReply Proxy::SyncCallReplyData::waitForMethodReply()
 {
-    std::unique_lock<std::mutex> lock{mutex_};
+    std::unique_lock lock{mutex_};
     cond_.wait(lock, [this](){ return arrived_; });
 
     //arrived_ = false; // Necessary if SyncCallReplyData instance is thread_local
@@ -152,17 +163,28 @@ void Proxy::registerSignalHandler( const std::string& interfaceName
                                  , const std::string& signalName
                                  , signal_handler signalHandler )
 {
+    SDBUS_CHECK_INTERFACE_NAME(interfaceName);
+    SDBUS_CHECK_MEMBER_NAME(signalName);
     SDBUS_THROW_ERROR_IF(!signalHandler, "Invalid signal handler provided", EINVAL);
 
     auto& interface = interfaces_[interfaceName];
 
-    InterfaceData::SignalData signalData{std::move(signalHandler), nullptr};
+    auto signalData = std::make_unique<InterfaceData::SignalData>(*this, std::move(signalHandler), nullptr);
     auto insertionResult = interface.signals_.emplace(signalName, std::move(signalData));
 
     auto inserted = insertionResult.second;
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register signal handler: handler already exists", EINVAL);
 }
 
+void Proxy::unregisterSignalHandler( const std::string& interfaceName
+                                   , const std::string& signalName )
+{
+    auto it = interfaces_.find(interfaceName);
+
+    if (it != interfaces_.end())
+        it->second.signals_.erase(signalName);
+}
+
 void Proxy::finishRegistration()
 {
     registerSignalHandlers(*connection_);
@@ -178,12 +200,13 @@ void Proxy::registerSignalHandlers(sdbus::internal::IConnection& connection)
         for (auto& signalItem : signalsOnInterface)
         {
             const auto& signalName = signalItem.first;
-            auto& slot = signalItem.second.slot_;
-            slot = connection.registerSignalHandler( objectPath_
-                                                   , interfaceName
-                                                   , signalName
-                                                   , &Proxy::sdbus_signal_handler
-                                                   , this );
+            auto* signalData = signalItem.second.get();
+            signalData->slot = connection.registerSignalHandler( destination_
+                                                               , objectPath_
+                                                               , interfaceName
+                                                               , signalName
+                                                               , &Proxy::sdbus_signal_handler
+                                                               , signalData);
         }
     }
 }
@@ -194,54 +217,123 @@ void Proxy::unregister()
     interfaces_.clear();
 }
 
+sdbus::IConnection& Proxy::getConnection() const
+{
+    return *connection_;
+}
+
+const std::string& Proxy::getObjectPath() const
+{
+    return objectPath_;
+}
+
+const Message* Proxy::getCurrentlyProcessedMessage() const
+{
+    return m_CurrentlyProcessedMessage.load(std::memory_order_relaxed);
+}
+
 int Proxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
 {
     auto* asyncCallData = static_cast<AsyncCalls::CallData*>(userData);
     assert(asyncCallData != nullptr);
     assert(asyncCallData->callback);
     auto& proxy = asyncCallData->proxy;
+    auto slot = asyncCallData->slot.get();
 
+    // We are removing the CallData item at the complete scope exit, after the callback has been invoked.
+    // We can't do it earlier (before callback invocation for example), because CallBack data (slot release)
+    // is the synchronization point between callback invocation and Proxy::unregister.
     SCOPE_EXIT
     {
-        // Slot may be null if we're doing blocking synchronous call implemented by means of asynchronous call,
-        // because in that case the call data is still alive on the stack, we don't need to manage it separately.
-        if (asyncCallData->slot)
-            proxy.pendingAsyncCalls_.removeCall(asyncCallData->slot.get());
+        // Remove call meta-data if it's a real async call (a sync call done in terms of async has slot == nullptr)
+        if (slot)
+            proxy.pendingAsyncCalls_.removeCall(slot);
     };
 
     auto message = Message::Factory::create<MethodReply>(sdbusMessage, &proxy.connection_->getSdBusInterface());
 
-    const auto* error = sd_bus_message_get_error(sdbusMessage);
-    if (error == nullptr)
+    proxy.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
+    SCOPE_EXIT
     {
-        asyncCallData->callback(message, nullptr);
+        proxy.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
+    };
+
+    try
+    {
+        const auto* error = sd_bus_message_get_error(sdbusMessage);
+        if (error == nullptr)
+        {
+            asyncCallData->callback(message, nullptr);
+        }
+        else
+        {
+            Error exception(error->name, error->message);
+            asyncCallData->callback(message, &exception);
+        }
     }
-    else
+    catch (const Error&)
     {
-        sdbus::Error exception(error->name, error->message);
-        asyncCallData->callback(message, &exception);
+        // Intentionally left blank -- sdbus-c++ exceptions shall not bubble up to the underlying C sd-bus library
     }
 
-    return 1;
+    return 0;
 }
 
 int Proxy::sdbus_signal_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
 {
-    auto* proxy = static_cast<Proxy*>(userData);
-    assert(proxy != nullptr);
+    auto* signalData = static_cast<InterfaceData::SignalData*>(userData);
+    assert(signalData != nullptr);
+    assert(signalData->callback);
 
-    auto message = Message::Factory::create<Signal>(sdbusMessage, &proxy->connection_->getSdBusInterface());
+    auto message = Message::Factory::create<Signal>(sdbusMessage, &signalData->proxy.connection_->getSdBusInterface());
 
-    // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = proxy->interfaces_[message.getInterfaceName()].signals_[message.getMemberName()].callback_;
-    assert(callback);
+    signalData->proxy.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
+    SCOPE_EXIT
+    {
+        signalData->proxy.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
+    };
 
-    callback(message);
+    try
+    {
+        signalData->callback(message);
+    }
+    catch (const Error&)
+    {
+        // Intentionally left blank -- sdbus-c++ exceptions shall not bubble up to the underlying C sd-bus library
+    }
 
-    return 1;
+    return 0;
 }
 
-}}
+}
+
+namespace sdbus {
+
+PendingAsyncCall::PendingAsyncCall(std::weak_ptr<void> callData)
+    : callData_(std::move(callData))
+{
+}
+
+void PendingAsyncCall::cancel()
+{
+    if (auto ptr = callData_.lock(); ptr != nullptr)
+    {
+        auto* callData = static_cast<internal::Proxy::AsyncCalls::CallData*>(ptr.get());
+        callData->proxy.pendingAsyncCalls_.removeCall(callData->slot.get());
+
+        // At this point, the callData item is being deleted, leading to the release of the
+        // sd-bus slot pointer. This release locks the global sd-bus mutex. If the async
+        // callback is currently being processed, the sd-bus mutex is locked by the event
+        // loop thread, thus access to the callData item is synchronized and thread-safe.
+    }
+}
+
+bool PendingAsyncCall::isPending() const
+{
+    return !callData_.expired();
+}
+
+}
 
 namespace sdbus {
 

src/Proxy.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Proxy.h
  *
@@ -35,10 +35,10 @@
 #include <map>
 #include <unordered_map>
 #include <mutex>
+#include <atomic>
 #include <condition_variable>
 
-namespace sdbus {
-namespace internal {
+namespace sdbus::internal {
 
     class Proxy
         : public IProxy
@@ -53,14 +53,21 @@ namespace internal {
 
         MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) override;
         MethodReply callMethod(const MethodCall& message, uint64_t timeout) override;
-        void callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout) override;
+        PendingAsyncCall callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout) override;
 
         void registerSignalHandler( const std::string& interfaceName
                                   , const std::string& signalName
                                   , signal_handler signalHandler ) override;
+        void unregisterSignalHandler( const std::string& interfaceName
+                                    , const std::string& signalName ) override;
+
         void finishRegistration() override;
         void unregister() override;
 
+        sdbus::IConnection& getConnection() const override;
+        const std::string& getObjectPath() const override;
+        const Message* getCurrentlyProcessedMessage() const override;
+
     private:
         class SyncCallReplyData
         {
@@ -82,6 +89,8 @@ namespace internal {
         static int sdbus_signal_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
 
     private:
+        friend PendingAsyncCall;
+
         std::unique_ptr< sdbus::internal::IConnection
                        , std::function<void(sdbus::internal::IConnection*)>
                        > connection_;
@@ -94,10 +103,20 @@ namespace internal {
             using SignalName = std::string;
             struct SignalData
             {
-                signal_handler callback_;
-                SlotPtr slot_;
+                SignalData(Proxy& proxy, signal_handler callback, Slot slot)
+                    : proxy(proxy)
+                    , callback(std::move(callback))
+                    , slot(std::move(slot))
+                {}
+                Proxy& proxy;
+                signal_handler callback;
+                // slot must be listed after callback to ensure that slot is destructed first.
+                // Destructing the slot will sd_bus_slot_unref() the callback.
+                // Only after sd_bus_slot_unref(), we can safely delete the callback. The bus mutex (SdBus::sdbusMutex_)
+                // ensures that sd_bus_slot_unref() and the callback execute sequentially.
+                Slot slot;
             };
-            std::map<SignalName, SignalData> signals_;
+            std::map<SignalName, std::unique_ptr<SignalData>> signals_;
         };
         std::map<InterfaceName, InterfaceData> interfaces_;
 
@@ -112,7 +131,7 @@ namespace internal {
             {
                 Proxy& proxy;
                 async_reply_handler callback;
-                MethodCall::Slot slot;
+                Slot slot;
             };
 
             ~AsyncCalls()
@@ -120,33 +139,49 @@ namespace internal {
                 clear();
             }
 
-            bool addCall(void* slot, std::unique_ptr<CallData>&& asyncCallData)
+            bool addCall(void* slot, std::shared_ptr<CallData> asyncCallData)
             {
-                std::lock_guard<std::mutex> lock(mutex_);
+                std::lock_guard lock(mutex_);
                 return calls_.emplace(slot, std::move(asyncCallData)).second;
             }
 
-            bool removeCall(void* slot)
+            void removeCall(void* slot)
             {
-                std::lock_guard<std::mutex> lock(mutex_);
-                return calls_.erase(slot) > 0;
+                std::unique_lock lock(mutex_);
+                if (auto it = calls_.find(slot); it != calls_.end())
+                {
+                    auto callData = std::move(it->second);
+                    calls_.erase(it);
+                    lock.unlock();
+
+                    // Releasing call slot pointer acquires global sd-bus mutex. We have to perform the release
+                    // out of the `mutex_' critical section here, because if the `removeCall` is called by some
+                    // thread and at the same time Proxy's async reply handler (which already holds global sd-bus
+                    // mutex) is in progress in a different thread, we get double-mutex deadlock.
+                }
             }
 
             void clear()
             {
-                std::unique_lock<std::mutex> lock(mutex_);
+                std::unique_lock lock(mutex_);
                 auto asyncCallSlots = std::move(calls_);
-                // Perform releasing of sd-bus slots outside of the calls_ critical section which avoids
-                // double mutex dead lock when the async reply handler is invoked at the same time.
+                calls_ = {};
                 lock.unlock();
+
+                // Releasing call slot pointer acquires global sd-bus mutex. We have to perform the release
+                // out of the `mutex_' critical section here, because if the `clear` is called by some thread
+                // and at the same time Proxy's async reply handler (which already holds global sd-bus
+                // mutex) is in progress in a different thread, we get double-mutex deadlock.
             }
 
         private:
-            std::unordered_map<void*, std::unique_ptr<CallData>> calls_;
             std::mutex mutex_;
+            std::unordered_map<void*, std::shared_ptr<CallData>> calls_;
         } pendingAsyncCalls_;
+
+        std::atomic<const Message*> m_CurrentlyProcessedMessage{nullptr};
     };
 
-}}
+}
 
 #endif /* SDBUS_CXX_INTERNAL_PROXY_H_ */

src/ScopeGuard.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file ScopeGuard.h
  *

src/SdBus.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file SdBus.cpp
  * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@@ -28,67 +28,74 @@
 #include "SdBus.h"
 #include <sdbus-c++/Error.h>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 sd_bus_message* SdBus::sd_bus_message_ref(sd_bus_message *m)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_ref(m);
 }
 
 sd_bus_message* SdBus::sd_bus_message_unref(sd_bus_message *m)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_unref(m);
 }
 
 int SdBus::sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_send(bus, m, cookie);
 }
 
 int SdBus::sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *ret_error, sd_bus_message **reply)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_call(bus, m, usec, ret_error, reply);
 }
 
 int SdBus::sd_bus_call_async(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m, sd_bus_message_handler_t callback, void *userdata, uint64_t usec)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_call_async(bus, slot, m, callback, userdata, usec);
 }
 
+int SdBus::sd_bus_message_new(sd_bus *bus, sd_bus_message **m, uint8_t type)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_message_new(bus, m, type);
+}
+
 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)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new_method_call(bus, m, destination, path, interface, member);
 }
 
 int SdBus::sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new_signal(bus, m, path, interface, member);
 }
 
 int SdBus::sd_bus_message_new_method_return(sd_bus_message *call, sd_bus_message **m)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new_method_return(call, m);
 }
 
 int SdBus::sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message **m, const sd_bus_error *e)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_message_new_method_error(call, m, e);
 }
@@ -96,7 +103,7 @@ int SdBus::sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message
 int SdBus::sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec)
 {
 #if LIBSYSTEMD_VERSION>=240
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_set_method_call_timeout(bus, usec);
 #else
@@ -109,7 +116,7 @@ int SdBus::sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec)
 int SdBus::sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret)
 {
 #if LIBSYSTEMD_VERSION>=240
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_get_method_call_timeout(bus, ret);
 #else
@@ -121,47 +128,84 @@ int SdBus::sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret)
 
 int SdBus::sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_properties_changed_strv(bus, path, interface, names);
 }
 
 int SdBus::sd_bus_emit_object_added(sd_bus *bus, const char *path)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_object_added(bus, path);
 }
 
 int SdBus::sd_bus_emit_object_removed(sd_bus *bus, const char *path)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_object_removed(bus, path);
 }
 
 int SdBus::sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_interfaces_added_strv(bus, path, interfaces);
 }
 
 int SdBus::sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_emit_interfaces_removed_strv(bus, path, interfaces);
 }
 
+int SdBus::sd_bus_open(sd_bus **ret)
+{
+    return ::sd_bus_open(ret);
+}
+
+int SdBus::sd_bus_open_system(sd_bus **ret)
+{
+    return ::sd_bus_open_system(ret);
+}
+
 int SdBus::sd_bus_open_user(sd_bus **ret)
 {
     return ::sd_bus_open_user(ret);
 }
 
-int SdBus::sd_bus_open_system(sd_bus **ret)
+int SdBus::sd_bus_open_user_with_address(sd_bus **ret, const char* address)
 {
-    return ::sd_bus_open_system(ret);
+    sd_bus* bus = nullptr;
+
+    int r = sd_bus_new(&bus);
+    if (r < 0)
+        return r;
+
+    r = sd_bus_set_address(bus, address);
+    if (r < 0)
+        return r;
+
+    r = sd_bus_set_bus_client(bus, true);
+    if (r < 0)
+        return r;
+
+    // Copying behavior from
+    // https://github.com/systemd/systemd/blob/fee6441601c979165ebcbb35472036439f8dad5f/src/libsystemd/sd-bus/sd-bus.c#L1381
+    // Here, we make the bus as trusted
+    r = sd_bus_set_trusted(bus, true);
+    if (r < 0)
+        return r;
+
+    r = sd_bus_start(bus);
+    if (r < 0)
+        return r;
+
+    *ret = bus;
+
+    return 0;
 }
 
 int SdBus::sd_bus_open_system_remote(sd_bus **ret, const char *host)
@@ -171,62 +215,72 @@ int SdBus::sd_bus_open_system_remote(sd_bus **ret, const char *host)
 
 int SdBus::sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_request_name(bus, name, flags);
 }
 
 int SdBus::sd_bus_release_name(sd_bus *bus, const char *name)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_release_name(bus, name);
 }
 
 int SdBus::sd_bus_get_unique_name(sd_bus *bus, const char **name)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
     return ::sd_bus_get_unique_name(bus, name);
 }
 
 int SdBus::sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_add_object_vtable(bus, slot, path, interface,  vtable, userdata);
 }
 
 int SdBus::sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_add_object_manager(bus, slot, path);
 }
 
 int SdBus::sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return :: sd_bus_add_match(bus, slot, match, callback, userdata);
 }
 
 sd_bus_slot* SdBus::sd_bus_slot_unref(sd_bus_slot *slot)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_slot_unref(slot);
 }
 
+int SdBus::sd_bus_new(sd_bus **ret)
+{
+    return ::sd_bus_new(ret);
+}
+
+int SdBus::sd_bus_start(sd_bus *bus)
+{
+    return ::sd_bus_start(bus);
+}
+
 int SdBus::sd_bus_process(sd_bus *bus, sd_bus_message **r)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     return ::sd_bus_process(bus, r);
 }
 
 int SdBus::sd_bus_get_poll_data(sd_bus *bus, PollData* data)
 {
-    std::unique_lock<std::recursive_mutex> lock(sdbusMutex_);
+    std::lock_guard lock(sdbusMutex_);
 
     auto r = ::sd_bus_get_fd(bus);
     if (r < 0)
@@ -253,4 +307,84 @@ sd_bus* SdBus::sd_bus_flush_close_unref(sd_bus *bus)
     return ::sd_bus_flush_close_unref(bus);
 }
 
-}}
+sd_bus* SdBus::sd_bus_close_unref(sd_bus *bus)
+{
+#if LIBSYSTEMD_VERSION>=241
+    return ::sd_bus_close_unref(bus);
+#else
+    ::sd_bus_close(bus);
+    return ::sd_bus_unref(bus);
+#endif
+}
+
+int SdBus::sd_bus_message_set_destination(sd_bus_message *m, const char *destination)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_message_set_destination(m, destination);
+}
+
+int SdBus::sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **c)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_query_sender_creds(m, mask, c);
+}
+
+sd_bus_creds* SdBus::sd_bus_creds_unref(sd_bus_creds *c)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_unref(c);
+}
+
+int SdBus::sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_pid(c, pid);
+}
+
+int SdBus::sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_uid(c, uid);
+}
+
+int SdBus::sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *euid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_euid(c, euid);
+}
+
+int SdBus::sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_gid(c, gid);
+}
+
+int SdBus::sd_bus_creds_get_egid(sd_bus_creds *c, uid_t *egid)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_egid(c, egid);
+}
+
+int SdBus::sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_supplementary_gids(c, gids);
+}
+
+int SdBus::sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **label)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_creds_get_selinux_context(c, label);
+}
+
+}

src/SdBus.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file SdBus.h
  * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@@ -31,7 +31,7 @@
 #include "ISdBus.h"
 #include <mutex>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 class SdBus final : public ISdBus
 {
@@ -43,6 +43,7 @@ public:
     virtual int sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *ret_error, sd_bus_message **reply) override;
     virtual int sd_bus_call_async(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m, sd_bus_message_handler_t callback, void *userdata, uint64_t usec) override;
 
+    virtual int sd_bus_message_new(sd_bus *bus, sd_bus_message **m, uint8_t type) override;
     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) override;
     virtual int sd_bus_message_new_signal(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member) override;
     virtual int sd_bus_message_new_method_return(sd_bus_message *call, sd_bus_message **m) override;
@@ -57,8 +58,10 @@ public:
     virtual int sd_bus_emit_interfaces_added_strv(sd_bus *bus, const char *path, char **interfaces) override;
     virtual int sd_bus_emit_interfaces_removed_strv(sd_bus *bus, const char *path, char **interfaces) override;
 
-    virtual int sd_bus_open_user(sd_bus **ret) override;
+    virtual int sd_bus_open(sd_bus **ret) override;
     virtual int sd_bus_open_system(sd_bus **ret) override;
+    virtual int sd_bus_open_user(sd_bus **ret) override;
+    virtual int sd_bus_open_user_with_address(sd_bus **ret, const char* address) override;
     virtual int sd_bus_open_system_remote(sd_bus **ret, const char* hsot) override;
     virtual int sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags) override;
     virtual int sd_bus_release_name(sd_bus *bus, const char *name) override;
@@ -68,16 +71,33 @@ public:
     virtual int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) override;
     virtual sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) override;
 
+    virtual int sd_bus_new(sd_bus **ret) override;
+    virtual int sd_bus_start(sd_bus *bus) override;
+
     virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) override;
     virtual int sd_bus_get_poll_data(sd_bus *bus, PollData* data) override;
 
     virtual int sd_bus_flush(sd_bus *bus) override;
     virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) override;
+    virtual sd_bus *sd_bus_close_unref(sd_bus *bus) override;
+
+    virtual int sd_bus_message_set_destination(sd_bus_message *m, const char *destination) override;
+
+    virtual int sd_bus_query_sender_creds(sd_bus_message *m, uint64_t mask, sd_bus_creds **c) override;
+    virtual sd_bus_creds* sd_bus_creds_unref(sd_bus_creds *c) override;
+
+    virtual int sd_bus_creds_get_pid(sd_bus_creds *c, pid_t *pid) override;
+    virtual int sd_bus_creds_get_uid(sd_bus_creds *c, uid_t *uid) override;
+    virtual int sd_bus_creds_get_euid(sd_bus_creds *c, uid_t *euid) override;
+    virtual int sd_bus_creds_get_gid(sd_bus_creds *c, gid_t *gid) override;
+    virtual int sd_bus_creds_get_egid(sd_bus_creds *c, gid_t *egid) override;
+    virtual int sd_bus_creds_get_supplementary_gids(sd_bus_creds *c, const gid_t **gids) override;
+    virtual int sd_bus_creds_get_selinux_context(sd_bus_creds *c, const char **label) override;
 
 private:
     std::recursive_mutex sdbusMutex_;
 };
 
-}}
+}
 
 #endif //SDBUS_C_SDBUS_H

src/Types.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Types.cpp
  *

src/Utils.h

@@ -0,0 +1,53 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file Utils.h
+ *
+ * Created on: Feb 9, 2022
+ * 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_INTERNAL_UTILS_H_
+#define SDBUS_CXX_INTERNAL_UTILS_H_
+
+#include <sdbus-c++/Error.h>
+#include <systemd/sd-bus.h>
+
+#if LIBSYSTEMD_VERSION>=246
+#define SDBUS_CHECK_OBJECT_PATH(_PATH)                                                                                              \
+    SDBUS_THROW_ERROR_IF(!sd_bus_object_path_is_valid(_PATH.c_str()), "Invalid object path '" + _PATH + "' provided", EINVAL)       \
+    /**/
+#define SDBUS_CHECK_INTERFACE_NAME(_NAME)                                                                                           \
+    SDBUS_THROW_ERROR_IF(!sd_bus_interface_name_is_valid(_NAME.c_str()), "Invalid interface name '" + _NAME + "' provided", EINVAL) \
+    /**/
+#define SDBUS_CHECK_SERVICE_NAME(_NAME)                                                                                             \
+    SDBUS_THROW_ERROR_IF(!sd_bus_service_name_is_valid(_NAME.c_str()), "Invalid service name '" + _NAME + "' provided", EINVAL)     \
+    /**/
+#define SDBUS_CHECK_MEMBER_NAME(_NAME)                                                                                              \
+    SDBUS_THROW_ERROR_IF(!sd_bus_member_name_is_valid(_NAME.c_str()), "Invalid member name '" + _NAME + "' provided", EINVAL)       \
+    /**/
+#else
+#define SDBUS_CHECK_OBJECT_PATH(_PATH)
+#define SDBUS_CHECK_INTERFACE_NAME(_NAME)
+#define SDBUS_CHECK_SERVICE_NAME(_NAME)
+#define SDBUS_CHECK_MEMBER_NAME(_NAME)
+#endif
+
+#endif /* SDBUS_CXX_INTERNAL_UTILS_H_ */

src/VTableUtils.c

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file VTableUtils.c
  *
@@ -36,18 +36,46 @@ sd_bus_vtable createVTableStartItem(uint64_t flags)
 sd_bus_vtable createVTableMethodItem( const char *member
                                     , const char *signature
                                     , const char *result
+                                    , const char *paramNames
                                     , sd_bus_message_handler_t handler
                                     , uint64_t flags )
 {
+#if LIBSYSTEMD_VERSION>=242
+    // We have to expand macro SD_BUS_METHOD_WITH_NAMES manually here, because the macro expects literal char strings
+    /*struct sd_bus_vtable vtableItem = SD_BUS_METHOD_WITH_NAMES(member, signature, innames, result, outnames, handler, flags);*/
+    struct sd_bus_vtable vtableItem =
+    {
+            .type = _SD_BUS_VTABLE_METHOD,
+            .flags = flags,
+            .x = {
+                .method = {
+                    .member = member,
+                    .signature = signature,
+                    .result = result,
+                    .handler = handler,
+                    .offset = 0,
+                    .names = paramNames,
+                },
+            },
+    };
+#else
+    (void)paramNames;
     struct sd_bus_vtable vtableItem = SD_BUS_METHOD(member, signature, result, handler, flags);
+#endif
     return vtableItem;
 }
 
 sd_bus_vtable createVTableSignalItem( const char *member
                                     , const char *signature
+                                    , const char *outnames
                                     , uint64_t flags )
 {
+#if LIBSYSTEMD_VERSION>=242
+    struct sd_bus_vtable vtableItem = SD_BUS_SIGNAL_WITH_NAMES(member, signature, outnames, flags);
+#else
+    (void)outnames;
     struct sd_bus_vtable vtableItem = SD_BUS_SIGNAL(member, signature, flags);
+#endif
     return vtableItem;
 }
 

src/VTableUtils.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file VTableUtils.h
  *
@@ -38,10 +38,12 @@ sd_bus_vtable createVTableStartItem(uint64_t flags);
 sd_bus_vtable createVTableMethodItem( const char *member
                                     , const char *signature
                                     , const char *result
+                                    , const char *paramNames
                                     , sd_bus_message_handler_t handler
                                     , uint64_t flags );
 sd_bus_vtable createVTableSignalItem( const char *member
                                     , const char *signature
+                                    , const char *outnames
                                     , uint64_t flags );
 sd_bus_vtable createVTablePropertyItem( const char *member
                                       , const char *signature

tests/CMakeLists.txt

@@ -1,37 +1,47 @@
 #-------------------------------
 # DOWNLOAD AND BUILD OF GOOGLETEST
-# https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project
 #-------------------------------
 
-configure_file(googletest-download/CMakeLists.txt.in googletest-download/CMakeLists.txt)
+set(GOOGLETEST_VERSION 1.10.0 CACHE STRING "Version of gmock to use")
+set(GOOGLETEST_GIT_REPO "https://github.com/google/googletest.git" CACHE STRING "A git repo to clone and build googletest from if gmock is not found in the system")
 
-execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
-    RESULT_VARIABLE result
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download)
+find_package(GTest ${GOOGLETEST_VERSION} CONFIG)
+if (NOT TARGET GTest::gmock)
+    # Try pkg-config if GTest was not found through CMake config
+    find_package(PkgConfig)
+    if (PkgConfig_FOUND)
+        pkg_check_modules(GMock IMPORTED_TARGET GLOBAL gmock>=${GOOGLETEST_VERSION})
+        if(TARGET PkgConfig::GMock)
+            add_library(GTest::gmock ALIAS PkgConfig::GMock)
+        endif()
+    endif()
+    # GTest was not found in the system, build it on our own
+    if (NOT TARGET GTest::gmock)
+        include(FetchContent)
 
-if(result)
-    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
+        message("Fetching googletest v${GOOGLETEST_VERSION}...")
+        FetchContent_Declare(googletest
+                            GIT_REPOSITORY ${GOOGLETEST_GIT_REPO}
+                            GIT_TAG        release-${GOOGLETEST_VERSION}
+                            GIT_SHALLOW    1
+                            UPDATE_COMMAND "")
+
+        #FetchContent_MakeAvailable(googletest) # Not available in CMake 3.13 :-( Let's do it manually:
+        FetchContent_GetProperties(googletest)
+        if(NOT googletest_POPULATED)
+            FetchContent_Populate(googletest)
+            set(gtest_force_shared_crt ON CACHE INTERNAL "" FORCE)
+            set(BUILD_GMOCK ON CACHE INTERNAL "" FORCE)
+            set(INSTALL_GTEST OFF CACHE INTERNAL "" FORCE)
+            set(BUILD_SHARED_LIBS_BAK ${BUILD_SHARED_LIBS})
+            set(BUILD_SHARED_LIBS OFF)
+            add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
+            set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_BAK})
+            add_library(GTest::gmock ALIAS gmock)
+        endif()
+    endif()
 endif()
 
-execute_process(COMMAND ${CMAKE_COMMAND} --build .
-    RESULT_VARIABLE result
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download)
-
-if(result)
-    message(FATAL_ERROR "Build step for googletest failed: ${result}")
-endif()
-
-set(gtest_force_shared_crt ON CACHE INTERNAL "" FORCE)
-set(BUILD_GMOCK ON CACHE INTERNAL "" FORCE)
-set(INSTALL_GTEST OFF CACHE INTERNAL "" FORCE)
-
-set(BUILD_SHARED_LIBS_BAK ${BUILD_SHARED_LIBS})
-set(BUILD_SHARED_LIBS OFF)
-add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
-                    ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
-                    EXCLUDE_FROM_ALL)
-set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_BAK})
-
 #-------------------------------
 # SOURCE FILES CONFIGURATION
 #-------------------------------
@@ -47,14 +57,23 @@ set(UNITTESTS_SRCS
 
 set(INTEGRATIONTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/integrationtests)
 set(INTEGRATIONTESTS_SRCS
-    ${INTEGRATIONTESTS_SOURCE_DIR}/AdaptorAndProxy_test.cpp
-    ${INTEGRATIONTESTS_SOURCE_DIR}/Connection_test.cpp
-    ${INTEGRATIONTESTS_SOURCE_DIR}/sdbus-c++-integration-tests.cpp
-    ${INTEGRATIONTESTS_SOURCE_DIR}/adaptor-glue.h
-    ${INTEGRATIONTESTS_SOURCE_DIR}/defs.h
-    ${INTEGRATIONTESTS_SOURCE_DIR}/proxy-glue.h
-    ${INTEGRATIONTESTS_SOURCE_DIR}/TestingAdaptor.h
-    ${INTEGRATIONTESTS_SOURCE_DIR}/TestingProxy.h)
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusConnectionTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusGeneralTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusMethodsTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusAsyncMethodsTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusSignalsTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusPropertiesTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/DBusStandardInterfacesTests.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/Defs.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/integrationtests-adaptor.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/integrationtests-proxy.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestFixture.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestFixture.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestAdaptor.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestAdaptor.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestProxy.h
+    ${INTEGRATIONTESTS_SOURCE_DIR}/TestProxy.cpp
+    ${INTEGRATIONTESTS_SOURCE_DIR}/sdbus-c++-integration-tests.cpp)
 
 set(PERFTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/perftests)
 set(STRESSTESTS_CLIENT_SRCS
@@ -84,16 +103,13 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 # BUILD INFORMATION
 #----------------------------------
 
-add_executable(sdbus-c++-unit-tests ${UNITTESTS_SRCS} $<TARGET_OBJECTS:sdbus-c++-objlib>)
-target_compile_definitions(sdbus-c++-unit-tests PRIVATE LIBSYSTEMD_VERSION=${SYSTEMD_VERSION})
-target_include_directories(sdbus-c++-unit-tests PRIVATE ${SYSTEMD_INCLUDE_DIRS}
-                                                        ${CMAKE_SOURCE_DIR}/src
-                                                        ${CMAKE_SOURCE_DIR}/include)
-target_link_libraries(sdbus-c++-unit-tests ${SYSTEMD_LIBRARIES} gmock gmock_main)
+add_executable(sdbus-c++-unit-tests ${UNITTESTS_SRCS})
+target_compile_definitions(sdbus-c++-unit-tests PRIVATE LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
+target_link_libraries(sdbus-c++-unit-tests sdbus-c++-objlib GTest::gmock)
 
 add_executable(sdbus-c++-integration-tests ${INTEGRATIONTESTS_SRCS})
-target_compile_definitions(sdbus-c++-integration-tests PRIVATE LIBSYSTEMD_VERSION=${SYSTEMD_VERSION})
-target_link_libraries(sdbus-c++-integration-tests sdbus-c++ gmock gmock_main)
+target_compile_definitions(sdbus-c++-integration-tests PRIVATE LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
+target_link_libraries(sdbus-c++-integration-tests sdbus-c++ GTest::gmock)
 
 # Manual performance and stress tests
 option(ENABLE_PERF_TESTS "Build and install manual performance tests (default OFF)" OFF)
@@ -104,6 +120,7 @@ if(ENABLE_PERF_TESTS OR ENABLE_STRESS_TESTS)
     find_package(Threads REQUIRED)
 
     if(ENABLE_PERF_TESTS)
+        message(STATUS "Building with performance tests")
         add_executable(sdbus-c++-perf-tests-client ${STRESSTESTS_CLIENT_SRCS})
         target_link_libraries(sdbus-c++-perf-tests-client sdbus-c++ Threads::Threads)
         add_executable(sdbus-c++-perf-tests-server ${STRESSTESTS_SERVER_SRCS})
@@ -111,6 +128,7 @@ if(ENABLE_PERF_TESTS OR ENABLE_STRESS_TESTS)
     endif()
 
     if(ENABLE_STRESS_TESTS)
+        message(STATUS "Building with stress tests")
         add_executable(sdbus-c++-stress-tests ${STRESSTESTS_SRCS})
         target_link_libraries(sdbus-c++-stress-tests sdbus-c++ Threads::Threads)
     endif()
@@ -122,19 +140,19 @@ endif()
 
 set(TESTS_INSTALL_PATH "/opt/test/bin" CACHE STRING "Specifies where the test binaries will be installed")
 
-install(TARGETS sdbus-c++-unit-tests DESTINATION ${TESTS_INSTALL_PATH})
-install(TARGETS sdbus-c++-integration-tests DESTINATION ${TESTS_INSTALL_PATH})
-install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/org.sdbuscpp.integrationtests.conf DESTINATION /etc/dbus-1/system.d)
+install(TARGETS sdbus-c++-unit-tests DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+install(TARGETS sdbus-c++-integration-tests DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/org.sdbuscpp.integrationtests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)
 
 if(ENABLE_PERF_TESTS)
-    install(TARGETS sdbus-c++-perf-tests-client DESTINATION ${TESTS_INSTALL_PATH})
-    install(TARGETS sdbus-c++-perf-tests-server DESTINATION ${TESTS_INSTALL_PATH})
-    install(FILES ${PERFTESTS_SOURCE_DIR}/files/org.sdbuscpp.perftests.conf DESTINATION /etc/dbus-1/system.d)
+    install(TARGETS sdbus-c++-perf-tests-client DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+    install(TARGETS sdbus-c++-perf-tests-server DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+    install(FILES ${PERFTESTS_SOURCE_DIR}/files/org.sdbuscpp.perftests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)
 endif()
 
 if(ENABLE_STRESS_TESTS)
-    install(TARGETS sdbus-c++-stress-tests DESTINATION ${TESTS_INSTALL_PATH})
-    install(FILES ${STRESSTESTS_SOURCE_DIR}/files/org.sdbuscpp.stresstests.conf DESTINATION /etc/dbus-1/system.d)
+    install(TARGETS sdbus-c++-stress-tests DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
+    install(FILES ${STRESSTESTS_SOURCE_DIR}/files/org.sdbuscpp.stresstests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)
 endif()
 
 #----------------------------------

tests/googletest-download/CMakeLists.txt.in

@@ -1,19 +0,0 @@
-# Taken from https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project
-
-cmake_minimum_required(VERSION 3.6)
-
-project(googletest-download NONE)
-
-include(ExternalProject)
-
-ExternalProject_Add(googletest
-    GIT_REPOSITORY    https://github.com/google/googletest.git
-    GIT_TAG           master
-    GIT_SHALLOW       1
-    SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
-    BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
-    UPDATE_COMMAND    ""
-    CONFIGURE_COMMAND ""
-    BUILD_COMMAND     ""
-    INSTALL_COMMAND   ""
-    TEST_COMMAND      "")

tests/integrationtests/AdaptorAndProxy_test.cpp

@@ -1,682 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file AdaptorAndProxy_test.cpp
- *
- * Created on: Jan 2, 2017
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-// Own
-#include "TestingAdaptor.h"
-#include "TestingProxy.h"
-
-// sdbus
-#include "sdbus-c++/sdbus-c++.h"
-
-// gmock
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-// STL
-#include <string>
-#include <thread>
-#include <tuple>
-#include <chrono>
-#include <fstream>
-#include <future>
-
-#include <unistd.h>
-
-using ::testing::Eq;
-using ::testing::DoubleEq;
-using ::testing::Gt;
-using ::testing::AnyOf;
-using ::testing::ElementsAre;
-using ::testing::SizeIs;
-using namespace std::chrono_literals;
-
-namespace
-{
-
-class AdaptorAndProxyFixture : public ::testing::Test
-{
-public:
-    static void SetUpTestCase()
-    {
-        s_connection->requestName(INTERFACE_NAME);
-        s_connection->enterProcessingLoopAsync();
-    }
-
-    static void TearDownTestCase()
-    {
-        s_connection->leaveProcessingLoop();
-        s_connection->releaseName(INTERFACE_NAME);
-    }
-
-    static bool waitUntil(std::atomic<bool>& flag, std::chrono::milliseconds timeout = 5s)
-    {
-        std::chrono::milliseconds elapsed{};
-        std::chrono::milliseconds step{5ms};
-        do {
-            std::this_thread::sleep_for(step);
-            elapsed += step;
-            if (elapsed > timeout)
-                return false;
-        } while (!flag);
-
-        return true;
-    }
-
-private:
-    void SetUp() override
-    {
-        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
-    }
-
-    void TearDown() override
-    {
-        m_proxy.reset();
-        m_adaptor.reset();
-    }
-
-public:
-    static std::unique_ptr<sdbus::IConnection> s_connection;
-
-    std::unique_ptr<TestingAdaptor> m_adaptor;
-    std::unique_ptr<TestingProxy> m_proxy;
-};
-
-std::unique_ptr<sdbus::IConnection> AdaptorAndProxyFixture::s_connection = sdbus::createSystemBusConnection();
-
-}
-
-/*-------------------------------------*/
-/* --          TEST CASES           -- */
-/*-------------------------------------*/
-
-TEST(AdaptorAndProxy, CanBeConstructedSuccesfully)
-{
-    auto connection = sdbus::createConnection();
-    connection->requestName(INTERFACE_NAME);
-
-    ASSERT_NO_THROW(TestingAdaptor adaptor(*connection));
-    ASSERT_NO_THROW(TestingProxy proxy(INTERFACE_NAME, OBJECT_PATH));
-
-    connection->releaseName(INTERFACE_NAME);
-}
-
-// Methods
-
-using SdbusTestObject = AdaptorAndProxyFixture;
-
-TEST_F(SdbusTestObject, CallsEmptyMethodSuccesfully)
-{
-    ASSERT_NO_THROW(m_proxy->noArgNoReturn());
-}
-
-TEST_F(SdbusTestObject, CallsMethodsWithBaseTypesSuccesfully)
-{
-    auto resInt = m_proxy->getInt();
-    ASSERT_THAT(resInt, Eq(INT32_VALUE));
-
-    auto multiplyRes = m_proxy->multiply(INT64_VALUE, DOUBLE_VALUE);
-    ASSERT_THAT(multiplyRes, Eq(INT64_VALUE * DOUBLE_VALUE));
-}
-
-TEST_F(SdbusTestObject, CallsMethodsWithTuplesSuccesfully)
-{
-    auto resTuple = m_proxy->getTuple();
-    ASSERT_THAT(std::get<0>(resTuple), Eq(UINT32_VALUE));
-    ASSERT_THAT(std::get<1>(resTuple), Eq(STRING_VALUE));
-}
-
-TEST_F(SdbusTestObject, CallsMethodsWithStructSuccesfully)
-{
-    sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>> a{};
-    auto vectorRes = m_proxy->getInts16FromStruct(a);
-    ASSERT_THAT(vectorRes, Eq(std::vector<int16_t>{0})); // because second item is by default initialized to 0
-
-
-    sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>> b{
-        UINT8_VALUE, INT16_VALUE, DOUBLE_VALUE, STRING_VALUE, {INT16_VALUE, -INT16_VALUE}
-    };
-    vectorRes = m_proxy->getInts16FromStruct(b);
-    ASSERT_THAT(vectorRes, Eq(std::vector<int16_t>{INT16_VALUE, INT16_VALUE, -INT16_VALUE}));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithVariantSuccesfully)
-{
-    sdbus::Variant v{DOUBLE_VALUE};
-    auto variantRes = m_proxy->processVariant(v);
-    ASSERT_THAT(variantRes.get<int32_t>(), Eq(static_cast<int32_t>(DOUBLE_VALUE)));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithStructVariantsAndGetMapSuccesfully)
-{
-    std::vector<int32_t> x{-2, 0, 2};
-    sdbus::Struct<sdbus::Variant, sdbus::Variant> y{false, true};
-    auto mapOfVariants = m_proxy->getMapOfVariants(x, y);
-    decltype(mapOfVariants) res{{-2, false}, {0, false}, {2, true}};
-
-    ASSERT_THAT(mapOfVariants[-2].get<bool>(), Eq(res[-2].get<bool>()));
-    ASSERT_THAT(mapOfVariants[0].get<bool>(), Eq(res[0].get<bool>()));
-    ASSERT_THAT(mapOfVariants[2].get<bool>(), Eq(res[2].get<bool>()));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithStructInStructSuccesfully)
-{
-    auto val = m_proxy->getStructInStruct();
-    ASSERT_THAT(val.get<0>(), Eq(STRING_VALUE));
-    ASSERT_THAT(std::get<0>(std::get<1>(val))[INT32_VALUE], Eq(INT32_VALUE));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithTwoStructsSuccesfully)
-{
-    auto val = m_proxy->sumStructItems({1, 2}, {3, 4});
-    ASSERT_THAT(val, Eq(1 + 2 + 3 + 4));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithTwoVectorsSuccesfully)
-{
-    auto val = m_proxy->sumVectorItems({1, 7}, {2, 3});
-    ASSERT_THAT(val, Eq(1 + 7 + 2 + 3));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithSignatureSuccesfully)
-{
-    auto resSignature = m_proxy->getSignature();
-    ASSERT_THAT(resSignature, Eq(SIGNATURE_VALUE));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithObjectPathSuccesfully)
-{
-    auto resObjectPath = m_proxy->getObjectPath();
-    ASSERT_THAT(resObjectPath, Eq(OBJECT_PATH_VALUE));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithUnixFdSuccesfully)
-{
-    auto resUnixFd = m_proxy->getUnixFd();
-    ASSERT_THAT(resUnixFd.get(), Gt(UNIX_FD_VALUE));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithComplexTypeSuccesfully)
-{
-    auto resComplex = m_proxy->getComplex();
-    ASSERT_THAT(resComplex.count(0), Eq(1));
-}
-
-TEST_F(SdbusTestObject, CallsMultiplyMethodWithNoReplyFlag)
-{
-    m_proxy->multiplyWithNoReply(INT64_VALUE, DOUBLE_VALUE);
-
-    ASSERT_TRUE(waitUntil(m_adaptor->m_wasMultiplyCalled));
-    ASSERT_THAT(m_adaptor->m_multiplyResult, Eq(INT64_VALUE * DOUBLE_VALUE));
-}
-
-TEST_F(SdbusTestObject, CallsMethodWithCustomTimeoutSuccessfully)
-{
-    auto res = m_proxy->doOperationWith500msTimeout(20); // The operation will take 20ms, but the timeout is 500ms, so we are fine
-    ASSERT_THAT(res, Eq(20));
-}
-
-TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenMethodTimesOut)
-{
-    try
-    {
-        m_proxy->doOperationWith500msTimeout(1000); // The operation will take 1s, but the timeout is 500ms, so we should time out
-        FAIL() << "Expected sdbus::Error exception";
-    }
-    catch (const sdbus::Error& e)
-    {
-        ASSERT_THAT(e.getName(), AnyOf("org.freedesktop.DBus.Error.Timeout", "org.freedesktop.DBus.Error.NoReply"));
-        ASSERT_THAT(e.getMessage(), AnyOf("Connection timed out", "Method call timed out"));
-    }
-    catch(...)
-    {
-        FAIL() << "Expected sdbus::Error exception";
-    }
-}
-
-TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenClientSideAsyncMethodTimesOut)
-{
-    try
-    {
-        std::promise<uint32_t> promise;
-        auto future = promise.get_future();
-        m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
-        {
-            if (err == nullptr)
-                promise.set_value(res);
-            else
-                promise.set_exception(std::make_exception_ptr(*err));
-        });
-
-        m_proxy->doOperationClientSideAsyncWith500msTimeout(1000); // The operation will take 1s, but the timeout is 500ms, so we should time out
-        future.get(), Eq(100);
-
-        FAIL() << "Expected sdbus::Error exception";
-    }
-    catch (const sdbus::Error& e)
-    {
-        ASSERT_THAT(e.getName(), AnyOf("org.freedesktop.DBus.Error.Timeout", "org.freedesktop.DBus.Error.NoReply"));
-        ASSERT_THAT(e.getMessage(), AnyOf("Connection timed out", "Method call timed out"));
-    }
-    catch(...)
-    {
-        FAIL() << "Expected sdbus::Error exception";
-    }
-}
-
-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());
-
-    ASSERT_TRUE(waitUntil(m_adaptor->m_wasThrowErrorCalled));
-}
-
-TEST_F(SdbusTestObject, RunsServerSideAsynchoronousMethodAsynchronously)
-{
-    // Yeah, this is kinda timing-dependent test, but times should be safe...
-    std::mutex mtx;
-    std::vector<uint32_t> results;
-    std::atomic<bool> invoke{};
-    std::atomic<int> startedCount{};
-    auto call = [&](uint32_t param)
-    {
-        TestingProxy proxy{INTERFACE_NAME, OBJECT_PATH};
-        ++startedCount;
-        while (!invoke) ;
-        auto result = proxy.doOperationAsync(param);
-        std::lock_guard<std::mutex> guard(mtx);
-        results.push_back(result);
-    };
-
-    std::thread invocations[]{std::thread{call, 1500}, std::thread{call, 1000}, std::thread{call, 500}};
-    while (startedCount != 3) ;
-    invoke = true;
-    std::for_each(std::begin(invocations), std::end(invocations), [](auto& t){ t.join(); });
-
-    ASSERT_THAT(results, ElementsAre(500, 1000, 1500));
-}
-
-TEST_F(SdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
-{
-    std::atomic<size_t> resultCount{};
-    std::atomic<bool> invoke{};
-    std::atomic<int> startedCount{};
-    auto call = [&]()
-    {
-        TestingProxy proxy{INTERFACE_NAME, OBJECT_PATH};
-        ++startedCount;
-        while (!invoke) ;
-
-        size_t localResultCount{};
-        for (size_t i = 0; i < 500; ++i)
-        {
-            auto result = proxy.doOperationAsync(i % 2);
-            if (result == (i % 2)) // Correct return value?
-                localResultCount++;
-        }
-
-        resultCount += localResultCount;
-    };
-
-    std::thread invocations[]{std::thread{call}, std::thread{call}, std::thread{call}};
-    while (startedCount != 3) ;
-    invoke = true;
-    std::for_each(std::begin(invocations), std::end(invocations), [](auto& t){ t.join(); });
-
-    ASSERT_THAT(resultCount, Eq(1500));
-}
-
-TEST_F(SdbusTestObject, InvokesMethodAsynchronouslyOnClientSide)
-{
-    std::promise<uint32_t> promise;
-    auto future = promise.get_future();
-    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
-    {
-        if (err == nullptr)
-            promise.set_value(res);
-        else
-            promise.set_exception(std::make_exception_ptr(*err));
-    });
-
-    m_proxy->doOperationClientSideAsync(100);
-
-    ASSERT_THAT(future.get(), Eq(100));
-}
-
-TEST_F(SdbusTestObject, InvokesErroneousMethodAsynchronouslyOnClientSide)
-{
-    std::promise<uint32_t> promise;
-    auto future = promise.get_future();
-    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
-    {
-        if (err == nullptr)
-            promise.set_value(res);
-        else
-            promise.set_exception(std::make_exception_ptr(*err));
-    });
-
-    m_proxy->doErroneousOperationClientSideAsync();
-
-    ASSERT_THROW(future.get(), sdbus::Error);
-}
-
-TEST_F(SdbusTestObject, FailsCallingNonexistentMethod)
-{
-    ASSERT_THROW(m_proxy->callNonexistentMethod(), sdbus::Error);
-}
-
-TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentInterface)
-{
-    ASSERT_THROW(m_proxy->callMethodOnNonexistentInterface(), sdbus::Error);
-}
-
-TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentDestination)
-{
-    TestingProxy proxy("sdbuscpp.destination.that.does.not.exist", OBJECT_PATH);
-    ASSERT_THROW(proxy.getInt(), sdbus::Error);
-}
-
-TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentObject)
-{
-    TestingProxy proxy(INTERFACE_NAME, "/sdbuscpp/path/that/does/not/exist");
-    ASSERT_THROW(proxy.getInt(), sdbus::Error);
-}
-
-TEST_F(SdbusTestObject, ReceivesTwoSignalsWhileMakingMethodCall)
-{
-    m_proxy->emitTwoSimpleSignals();
-
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithMap));
-}
-
-#if LIBSYSTEMD_VERSION>=240
-TEST_F(SdbusTestObject, CanSetGeneralMethodTimeoutWithLibsystemdVersionGreaterThan239)
-{
-    s_connection->setMethodCallTimeout(5000000);
-    ASSERT_THAT(s_connection->getMethodCallTimeout(), Eq(5000000));
-}
-#else
-TEST_F(SdbusTestObject, CannotSetGeneralMethodTimeoutWithLibsystemdVersionLessThan240)
-{
-    ASSERT_THROW(s_connection->setMethodCallTimeout(5000000), sdbus::Error);
-    ASSERT_THROW(s_connection->getMethodCallTimeout(), sdbus::Error);
-}
-#endif
-
-// Signals
-
-TEST_F(SdbusTestObject, EmitsSimpleSignalSuccesfully)
-{
-    m_adaptor->emitSimpleSignal();
-
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
-}
-
-TEST_F(SdbusTestObject, EmitsSignalWithMapSuccesfully)
-{
-    m_adaptor->emitSignalWithMap({{0, "zero"}, {1, "one"}});
-
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithMap));
-    ASSERT_THAT(m_proxy->m_mapFromSignal[0], Eq("zero"));
-    ASSERT_THAT(m_proxy->m_mapFromSignal[1], Eq("one"));
-}
-
-TEST_F(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
-{
-    double d = 3.14;
-    m_adaptor->emitSignalWithVariant(d);
-
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithVariant));
-    ASSERT_THAT(m_proxy->m_variantFromSignal, DoubleEq(d));
-}
-
-TEST_F(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
-{
-    m_adaptor->emitSignalWithoutRegistration({"platform", {"av"}});
-
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithSignature));
-    ASSERT_THAT(m_proxy->m_signatureFromSignal["platform"], Eq("av"));
-}
-
-// Properties
-
-TEST_F(SdbusTestObject, ReadsReadOnlyPropertySuccesfully)
-{
-    ASSERT_THAT(m_proxy->state(), Eq(DEFAULT_STATE_VALUE));
-}
-
-TEST_F(SdbusTestObject, FailsWritingToReadOnlyProperty)
-{
-    ASSERT_THROW(m_proxy->state("new_value"), sdbus::Error);
-}
-
-TEST_F(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
-{
-    uint32_t newActionValue = 5678;
-
-    m_proxy->action(newActionValue);
-
-    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
-}
-
-// Standard D-Bus interfaces
-
-TEST_F(SdbusTestObject, PingsViaPeerInterface)
-{
-    ASSERT_NO_THROW(m_proxy->Ping());
-}
-
-TEST_F(SdbusTestObject, AnswersMachineUuidViaPeerInterface)
-{
-    // If /etc/machine-id does not exist in your system (which is very likely because you have
-    // a non-systemd Linux), org.freedesktop.DBus.Peer.GetMachineId() will not work. To solve
-    // this, you can create /etc/machine-id yourself as symlink to /var/lib/dbus/machine-id,
-    // and then org.freedesktop.DBus.Peer.GetMachineId() will start to work.
-    if (::access("/etc/machine-id", F_OK) == -1)
-        GTEST_SKIP() << "/etc/machine-id file does not exist, GetMachineId() will not work";
-
-    ASSERT_NO_THROW(m_proxy->GetMachineId());
-}
-
-TEST_F(SdbusTestObject, AnswersXmlApiDescriptionViaIntrospectableInterface)
-{
-    ASSERT_THAT(m_proxy->Introspect(), Eq(m_adaptor->getExpectedXmlApiDescription()));
-}
-
-TEST_F(SdbusTestObject, GetsPropertyViaPropertiesInterface)
-{
-    ASSERT_THAT(m_proxy->Get(INTERFACE_NAME, "state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
-}
-
-TEST_F(SdbusTestObject, SetsPropertyViaPropertiesInterface)
-{
-    uint32_t newActionValue = 2345;
-
-    m_proxy->Set(INTERFACE_NAME, "action", newActionValue);
-
-    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
-}
-
-TEST_F(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
-{
-    const auto properties = m_proxy->GetAll(INTERFACE_NAME);
-
-    ASSERT_THAT(properties, SizeIs(3));
-    EXPECT_THAT(properties.at("state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
-    EXPECT_THAT(properties.at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
-    EXPECT_THAT(properties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
-}
-
-TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
-{
-    std::atomic<bool> signalReceived{false};
-    m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const std::string& interfaceName
-                                                             , const std::map<std::string, sdbus::Variant>& changedProperties
-                                                             , const std::vector<std::string>& /*invalidatedProperties*/ )
-    {
-        EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
-        EXPECT_THAT(changedProperties, SizeIs(1));
-        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(!DEFAULT_BLOCKING_VALUE));
-        signalReceived = true;
-    };
-
-    m_proxy->blocking(!DEFAULT_BLOCKING_VALUE);
-    m_proxy->action(DEFAULT_ACTION_VALUE*2);
-    m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME, {"blocking"});
-
-    ASSERT_TRUE(waitUntil(signalReceived));
-}
-
-TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForAllProperties)
-{
-    std::atomic<bool> signalReceived{false};
-    m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const std::string& interfaceName
-                                                             , const std::map<std::string, sdbus::Variant>& changedProperties
-                                                             , const std::vector<std::string>& invalidatedProperties )
-    {
-        EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
-        EXPECT_THAT(changedProperties, SizeIs(1));
-        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
-        ASSERT_THAT(invalidatedProperties, SizeIs(1));
-        EXPECT_THAT(invalidatedProperties[0], Eq("action"));
-        signalReceived = true;
-    };
-
-    m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME);
-
-    ASSERT_TRUE(waitUntil(signalReceived));
-}
-
-TEST_F(SdbusTestObject, GetsZeroManagedObjectsIfHasNoSubPathObjects)
-{
-    const auto objectsInterfacesAndProperties = m_proxy->GetManagedObjects();
-
-    ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(0));
-}
-
-TEST_F(SdbusTestObject, GetsManagedObjectsSuccessfully)
-{
-    auto subObject1 = sdbus::createObject(*s_connection, "/sub/path1");
-    subObject1->registerProperty("aProperty1").onInterface("org.sdbuscpp.integrationtests.iface1").withGetter([]{return uint8_t{123};});
-    subObject1->finishRegistration();
-    auto subObject2 = sdbus::createObject(*s_connection, "/sub/path2");
-    subObject2->registerProperty("aProperty2").onInterface("org.sdbuscpp.integrationtests.iface2").withGetter([]{return "hi";});
-    subObject2->finishRegistration();
-
-    const auto objectsInterfacesAndProperties = m_proxy->GetManagedObjects();
-
-    ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(2));
-    EXPECT_THAT(objectsInterfacesAndProperties.at("/sub/path1").at("org.sdbuscpp.integrationtests.iface1").at("aProperty1").get<uint8_t>(), Eq(123));
-    EXPECT_THAT(objectsInterfacesAndProperties.at("/sub/path2").at("org.sdbuscpp.integrationtests.iface2").at("aProperty2").get<std::string>(), Eq("hi"));
-}
-
-TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterfaces)
-{
-    std::atomic<bool> signalReceived{false};
-    m_proxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                           , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
-    {
-        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
-        EXPECT_THAT(interfacesAndProperties, SizeIs(1));
-        EXPECT_THAT(interfacesAndProperties.count(INTERFACE_NAME), Eq(1));
-        EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(3));
-        signalReceived = true;
-    };
-
-    m_adaptor->emitInterfacesAddedSignal({INTERFACE_NAME});
-
-    ASSERT_TRUE(waitUntil(signalReceived));
-}
-
-TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces)
-{
-    std::atomic<bool> signalReceived{false};
-    m_proxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                           , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
-    {
-        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
-        EXPECT_THAT(interfacesAndProperties, SizeIs(5)); // INTERFACE_NAME + 4 standard interfaces
-        EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(3)); // 3 properties under INTERFACE_NAME
-        signalReceived = true;
-    };
-
-    m_adaptor->emitInterfacesAddedSignal();
-
-    ASSERT_TRUE(waitUntil(signalReceived));
-}
-
-TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfaces)
-{
-    std::atomic<bool> signalReceived{false};
-    m_proxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                             , const std::vector<std::string>& interfaces )
-    {
-        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
-        ASSERT_THAT(interfaces, SizeIs(1));
-        EXPECT_THAT(interfaces[0], Eq(INTERFACE_NAME));
-        signalReceived = true;
-    };
-
-    m_adaptor->emitInterfacesRemovedSignal({INTERFACE_NAME});
-
-    ASSERT_TRUE(waitUntil(signalReceived));
-}
-
-TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForAllObjectInterfaces)
-{
-    std::atomic<bool> signalReceived{false};
-    m_proxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                             , const std::vector<std::string>& interfaces )
-    {
-        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
-        ASSERT_THAT(interfaces, SizeIs(5)); // INTERFACE_NAME + 4 standard interfaces
-        signalReceived = true;
-    };
-
-    m_adaptor->emitInterfacesRemovedSignal();
-
-    ASSERT_TRUE(waitUntil(signalReceived));
-}

tests/integrationtests/Connection_test.cpp

@@ -1,92 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file Connection_test.cpp
- *
- * Created on: Jan 2, 2017
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-// Own
-#include "defs.h"
-
-// sdbus
-#include <sdbus-c++/Error.h>
-#include <sdbus-c++/IConnection.h>
-
-// gmock
-#include <gtest/gtest.h>
-#include <gmock/gmock.h>
-
-// STL
-#include <thread>
-
-using ::testing::Eq;
-
-
-/*-------------------------------------*/
-/* --          TEST CASES           -- */
-/*-------------------------------------*/
-
-TEST(Connection, CanBeDefaultConstructed)
-{
-    ASSERT_NO_THROW(sdbus::createConnection());
-}
-
-TEST(Connection, CanRequestRegisteredDbusName)
-{
-    auto connection = sdbus::createConnection();
-
-    ASSERT_NO_THROW(connection->requestName(INTERFACE_NAME));
-    connection->releaseName(INTERFACE_NAME);
-}
-
-TEST(Connection, CannotRequestNonregisteredDbusName)
-{
-    auto connection = sdbus::createConnection();
-    ASSERT_THROW(connection->requestName("some.random.not.supported.dbus.name"), sdbus::Error);
-}
-
-TEST(Connection, CanReleasedRequestedName)
-{
-    auto connection = sdbus::createConnection();
-
-    connection->requestName(INTERFACE_NAME);
-    ASSERT_NO_THROW(connection->releaseName(INTERFACE_NAME));
-}
-
-TEST(Connection, CannotReleaseNonrequestedName)
-{
-    auto connection = sdbus::createConnection();
-    ASSERT_THROW(connection->releaseName("some.random.nonrequested.name"), sdbus::Error);
-}
-
-TEST(Connection, CanEnterAndLeaveProcessingLoop)
-{
-    auto connection = sdbus::createConnection();
-    connection->requestName(INTERFACE_NAME);
-
-    std::thread t([&](){ connection->enterProcessingLoop(); });
-    connection->leaveProcessingLoop();
-
-    t.join();
-
-    connection->releaseName(INTERFACE_NAME);
-}

tests/integrationtests/DBusAsyncMethodsTests.cpp

@@ -0,0 +1,240 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file DBusAsyncMethodsTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::Le;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenClientSideAsyncMethodTimesOut)
+{
+    std::chrono::time_point<std::chrono::steady_clock> start;
+    try
+    {
+        std::promise<uint32_t> promise;
+        auto future = promise.get_future();
+        m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+        {
+            if (err == nullptr)
+                promise.set_value(res);
+            else
+                promise.set_exception(std::make_exception_ptr(*err));
+        });
+
+        start = std::chrono::steady_clock::now();
+        m_proxy->doOperationClientSideAsyncWithTimeout(1us, 1000); // The operation will take 1s, but the timeout is 500ms, so we should time out
+        future.get();
+
+        FAIL() << "Expected sdbus::Error exception";
+    }
+    catch (const sdbus::Error& e)
+    {
+        ASSERT_THAT(e.getName(), AnyOf("org.freedesktop.DBus.Error.Timeout", "org.freedesktop.DBus.Error.NoReply"));
+        ASSERT_THAT(e.getMessage(), AnyOf("Connection timed out", "Method call timed out"));
+        auto measuredTimeout = std::chrono::steady_clock::now() - start;
+        ASSERT_THAT(measuredTimeout, Le(50ms));
+    }
+    catch(...)
+    {
+        FAIL() << "Expected sdbus::Error exception";
+    }
+}
+
+TEST_F(SdbusTestObject, RunsServerSideAsynchoronousMethodAsynchronously)
+{
+    // Yeah, this is kinda timing-dependent test, but times should be safe...
+    std::mutex mtx;
+    std::vector<uint32_t> results;
+    std::atomic<bool> invoke{};
+    std::atomic<int> startedCount{};
+    auto call = [&](uint32_t param)
+    {
+        TestProxy proxy{BUS_NAME, OBJECT_PATH};
+        ++startedCount;
+        while (!invoke) ;
+        auto result = proxy.doOperationAsync(param);
+        std::lock_guard<std::mutex> guard(mtx);
+        results.push_back(result);
+    };
+
+    std::thread invocations[]{std::thread{call, 1500}, std::thread{call, 1000}, std::thread{call, 500}};
+    while (startedCount != 3) ;
+    invoke = true;
+    std::for_each(std::begin(invocations), std::end(invocations), [](auto& t){ t.join(); });
+
+    ASSERT_THAT(results, ElementsAre(500, 1000, 1500));
+}
+
+TEST_F(SdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
+{
+    std::atomic<size_t> resultCount{};
+    std::atomic<bool> invoke{};
+    std::atomic<int> startedCount{};
+    auto call = [&]()
+    {
+        TestProxy proxy{BUS_NAME, OBJECT_PATH};
+        ++startedCount;
+        while (!invoke) ;
+
+        size_t localResultCount{};
+        for (size_t i = 0; i < 500; ++i)
+        {
+            auto result = proxy.doOperationAsync(i % 2);
+            if (result == (i % 2)) // Correct return value?
+                localResultCount++;
+        }
+
+        resultCount += localResultCount;
+    };
+
+    std::thread invocations[]{std::thread{call}, std::thread{call}, std::thread{call}};
+    while (startedCount != 3) ;
+    invoke = true;
+    std::for_each(std::begin(invocations), std::end(invocations), [](auto& t){ t.join(); });
+
+    ASSERT_THAT(resultCount, Eq(1500));
+}
+
+TEST_F(SdbusTestObject, InvokesMethodAsynchronouslyOnClientSide)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+    {
+        if (err == nullptr)
+            promise.set_value(res);
+        else
+            promise.set_exception(std::make_exception_ptr(*err));
+    });
+
+    m_proxy->doOperationClientSideAsync(100);
+
+    ASSERT_THAT(future.get(), Eq(100));
+}
+
+TEST_F(SdbusTestObject, AnswersThatAsyncCallIsPendingIfItIsInProgress)
+{
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){});
+
+    auto call = m_proxy->doOperationClientSideAsync(100);
+
+    ASSERT_TRUE(call.isPending());
+}
+
+TEST_F(SdbusTestObject, CancelsPendingAsyncCallOnClientSide)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){ promise.set_value(1); });
+    auto call = m_proxy->doOperationClientSideAsync(100);
+
+    call.cancel();
+
+    ASSERT_THAT(future.wait_for(300ms), Eq(std::future_status::timeout));
+}
+
+TEST_F(SdbusTestObject, AnswersThatAsyncCallIsNotPendingAfterItHasBeenCancelled)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){ promise.set_value(1); });
+    auto call = m_proxy->doOperationClientSideAsync(100);
+
+    call.cancel();
+
+    ASSERT_FALSE(call.isPending());
+}
+
+TEST_F(SdbusTestObject, AnswersThatAsyncCallIsNotPendingAfterItHasBeenCompleted)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){ promise.set_value(1); });
+
+    auto call = m_proxy->doOperationClientSideAsync(0);
+    (void) future.get(); // Wait for the call to finish
+
+    ASSERT_TRUE(waitUntil([&call](){ return !call.isPending(); }));
+}
+
+TEST_F(SdbusTestObject, AnswersThatDefaultConstructedAsyncCallIsNotPending)
+{
+    sdbus::PendingAsyncCall call;
+
+    ASSERT_FALSE(call.isPending());
+}
+
+TEST_F(SdbusTestObject, SupportsAsyncCallCopyAssignment)
+{
+    sdbus::PendingAsyncCall call;
+
+    call = m_proxy->doOperationClientSideAsync(100);
+
+    ASSERT_TRUE(call.isPending());
+}
+
+TEST_F(SdbusTestObject, InvokesErroneousMethodAsynchronouslyOnClientSide)
+{
+    std::promise<uint32_t> promise;
+    auto future = promise.get_future();
+    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+    {
+        if (err == nullptr)
+            promise.set_value(res);
+        else
+            promise.set_exception(std::make_exception_ptr(*err));
+    });
+
+    m_proxy->doErroneousOperationClientSideAsync();
+
+    ASSERT_THROW(future.get(), sdbus::Error);
+}

tests/integrationtests/DBusConnectionTests.cpp

@@ -0,0 +1,133 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file DBusConnectionTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+// Own
+#include "Defs.h"
+
+// sdbus
+#include <sdbus-c++/Error.h>
+#include <sdbus-c++/IConnection.h>
+
+// gmock
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+// STL
+#include <thread>
+#include <chrono>
+
+using ::testing::Eq;
+using namespace sdbus::test;
+using namespace std::chrono_literals;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST(Connection, CanBeDefaultConstructed)
+{
+    ASSERT_NO_THROW(auto con = sdbus::createConnection());
+}
+
+TEST(Connection, CanRequestRegisteredDbusName)
+{
+    auto connection = sdbus::createConnection();
+
+    ASSERT_NO_THROW(connection->requestName(BUS_NAME))
+        << "Perhaps you've forgotten to copy `org.sdbuscpp.integrationtests.conf` file to `/etc/dbus-1/system.d` directory before running the tests?";
+}
+
+TEST(Connection, CannotRequestNonregisteredDbusName)
+{
+    auto connection = sdbus::createConnection();
+    ASSERT_THROW(connection->requestName("some.random.not.supported.dbus.name"), sdbus::Error);
+}
+
+TEST(Connection, CanReleasedRequestedName)
+{
+    auto connection = sdbus::createConnection();
+
+    connection->requestName(BUS_NAME);
+    ASSERT_NO_THROW(connection->releaseName(BUS_NAME));
+}
+
+TEST(Connection, CannotReleaseNonrequestedName)
+{
+    auto connection = sdbus::createConnection();
+    ASSERT_THROW(connection->releaseName("some.random.nonrequested.name"), sdbus::Error);
+}
+
+TEST(Connection, CanEnterAndLeaveEventLoop)
+{
+    auto connection = sdbus::createConnection();
+    connection->requestName(BUS_NAME);
+
+    std::thread t([&](){ connection->enterEventLoop(); });
+    connection->leaveEventLoop();
+
+    t.join();
+}
+
+TEST(Connection, PollDataGetZeroTimeout)
+{
+    sdbus::IConnection::PollData pd{};
+    pd.timeout_usec = 0;
+    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
+    EXPECT_THAT(pd.getRelativeTimeout().value(), Eq(std::chrono::microseconds::zero()));
+    EXPECT_THAT(pd.getPollTimeout(), Eq(0));
+}
+
+TEST(Connection, PollDataGetInfiniteTimeout)
+{
+    sdbus::IConnection::PollData pd{};
+    pd.timeout_usec = UINT64_MAX;
+    ASSERT_FALSE(pd.getRelativeTimeout().has_value());
+    EXPECT_THAT(pd.getPollTimeout(), Eq(-1));
+}
+
+TEST(Connection, PollDataGetZeroRelativeTimeoutForPast)
+{
+    sdbus::IConnection::PollData pd{};
+    auto past = std::chrono::steady_clock::now() - 10s;
+    pd.timeout_usec = std::chrono::duration_cast<std::chrono::microseconds>(past.time_since_epoch()).count();
+    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
+    EXPECT_THAT(pd.getRelativeTimeout().value(), Eq(0us));
+    EXPECT_THAT(pd.getPollTimeout(), Eq(0));
+}
+
+TEST(Connection, PollDataGetRelativeTimeoutInTolerance)
+{
+    sdbus::IConnection::PollData pd{};
+    constexpr auto TIMEOUT = 1s;
+    constexpr auto TOLERANCE = 100ms;
+    auto future = std::chrono::steady_clock::now() + TIMEOUT;
+    pd.timeout_usec = std::chrono::duration_cast<std::chrono::microseconds>(future.time_since_epoch()).count();
+    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
+    EXPECT_GE(pd.getRelativeTimeout().value(), TIMEOUT - TOLERANCE);
+    EXPECT_LE(pd.getRelativeTimeout().value(), TIMEOUT + TOLERANCE);
+    EXPECT_GE(pd.getPollTimeout(), 900);
+    EXPECT_LE(pd.getPollTimeout(), 1100);
+}

tests/integrationtests/DBusGeneralTests.cpp

@@ -0,0 +1,132 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file DBusGeneralTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "TestFixture.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::ElementsAre;
+using ::testing::Eq;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using AConnection = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST(AdaptorAndProxy, CanBeConstructedSuccesfully)
+{
+    auto connection = sdbus::createConnection();
+    connection->requestName(BUS_NAME);
+
+    ASSERT_NO_THROW(TestAdaptor adaptor(*connection, OBJECT_PATH));
+    ASSERT_NO_THROW(TestProxy proxy(BUS_NAME, OBJECT_PATH));
+}
+
+TEST_F(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRule)
+{
+    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    std::atomic<bool> matchingMessageReceived{false};
+    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    {
+        if(msg.getPath() == OBJECT_PATH)
+            matchingMessageReceived = true;
+    });
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(matchingMessageReceived));
+}
+
+TEST_F(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedSlot)
+{
+    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    std::atomic<bool> matchingMessageReceived{false};
+    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    {
+        if(msg.getPath() == OBJECT_PATH)
+            matchingMessageReceived = true;
+    });
+    slot.reset();
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_FALSE(waitUntil(matchingMessageReceived, 2s));
+}
+
+TEST_F(AConnection, CanAddFloatingMatchRule)
+{
+    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    std::atomic<bool> matchingMessageReceived{false};
+    auto con = sdbus::createSystemBusConnection();
+    con->enterEventLoopAsync();
+    auto callback = [&](sdbus::Message& msg)
+    {
+        if(msg.getPath() == OBJECT_PATH)
+            matchingMessageReceived = true;
+    };
+    con->addMatch(matchRule, std::move(callback), sdbus::floating_slot);
+    m_adaptor->emitSimpleSignal();
+    assert(waitUntil(matchingMessageReceived, 2s));
+    matchingMessageReceived = false;
+
+    con.reset();
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_FALSE(waitUntil(matchingMessageReceived, 2s));
+}
+
+TEST_F(AConnection, WillNotPassToMatchCallbackMessagesThatDoNotMatchTheRule)
+{
+    auto matchRule = "type='signal',interface='" + INTERFACE_NAME + "',member='simpleSignal'";
+    std::atomic<size_t> numberOfMatchingMessages{};
+    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    {
+        if(msg.getMemberName() == "simpleSignal")
+            numberOfMatchingMessages++;
+    });
+    auto adaptor2 = std::make_unique<TestAdaptor>(*s_adaptorConnection, OBJECT_PATH_2);
+
+    m_adaptor->emitSignalWithMap({});
+    adaptor2->emitSimpleSignal();
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil([&](){ return numberOfMatchingMessages == 2; }));
+    ASSERT_FALSE(waitUntil([&](){ return numberOfMatchingMessages > 2; }, 1s));
+}

tests/integrationtests/DBusMethodsTests.cpp

@@ -0,0 +1,274 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file DBusMethodsTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::Le;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using ::testing::NotNull;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, CallsEmptyMethodSuccesfully)
+{
+    ASSERT_NO_THROW(m_proxy->noArgNoReturn());
+}
+
+TEST_F(SdbusTestObject, CallsMethodsWithBaseTypesSuccesfully)
+{
+    auto resInt = m_proxy->getInt();
+    ASSERT_THAT(resInt, Eq(INT32_VALUE));
+
+    auto multiplyRes = m_proxy->multiply(INT64_VALUE, DOUBLE_VALUE);
+    ASSERT_THAT(multiplyRes, Eq(INT64_VALUE * DOUBLE_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodsWithTuplesSuccesfully)
+{
+    auto resTuple = m_proxy->getTuple();
+    ASSERT_THAT(std::get<0>(resTuple), Eq(UINT32_VALUE));
+    ASSERT_THAT(std::get<1>(resTuple), Eq(STRING_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodsWithStructSuccesfully)
+{
+    sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>> a{};
+    auto vectorRes = m_proxy->getInts16FromStruct(a);
+    ASSERT_THAT(vectorRes, Eq(std::vector<int16_t>{0})); // because second item is by default initialized to 0
+
+
+    sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>> b{
+        UINT8_VALUE, INT16_VALUE, DOUBLE_VALUE, STRING_VALUE, {INT16_VALUE, -INT16_VALUE}
+    };
+    vectorRes = m_proxy->getInts16FromStruct(b);
+    ASSERT_THAT(vectorRes, Eq(std::vector<int16_t>{INT16_VALUE, INT16_VALUE, -INT16_VALUE}));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithVariantSuccesfully)
+{
+    sdbus::Variant v{DOUBLE_VALUE};
+    auto variantRes = m_proxy->processVariant(v);
+    ASSERT_THAT(variantRes.get<int32_t>(), Eq(static_cast<int32_t>(DOUBLE_VALUE)));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithStructVariantsAndGetMapSuccesfully)
+{
+    std::vector<int32_t> x{-2, 0, 2};
+    sdbus::Struct<sdbus::Variant, sdbus::Variant> y{false, true};
+    auto mapOfVariants = m_proxy->getMapOfVariants(x, y);
+    decltype(mapOfVariants) res{{-2, false}, {0, false}, {2, true}};
+
+    ASSERT_THAT(mapOfVariants[-2].get<bool>(), Eq(res[-2].get<bool>()));
+    ASSERT_THAT(mapOfVariants[0].get<bool>(), Eq(res[0].get<bool>()));
+    ASSERT_THAT(mapOfVariants[2].get<bool>(), Eq(res[2].get<bool>()));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithStructInStructSuccesfully)
+{
+    auto val = m_proxy->getStructInStruct();
+    ASSERT_THAT(val.get<0>(), Eq(STRING_VALUE));
+    ASSERT_THAT(std::get<0>(std::get<1>(val))[INT32_VALUE], Eq(INT32_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithTwoStructsSuccesfully)
+{
+    auto val = m_proxy->sumStructItems({1, 2}, {3, 4});
+    ASSERT_THAT(val, Eq(1 + 2 + 3 + 4));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithTwoVectorsSuccesfully)
+{
+    auto val = m_proxy->sumVectorItems({1, 7}, {2, 3});
+    ASSERT_THAT(val, Eq(1 + 7 + 2 + 3));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithSignatureSuccesfully)
+{
+    auto resSignature = m_proxy->getSignature();
+    ASSERT_THAT(resSignature, Eq(SIGNATURE_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithObjectPathSuccesfully)
+{
+    auto resObjectPath = m_proxy->getObjPath();
+    ASSERT_THAT(resObjectPath, Eq(OBJECT_PATH_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithUnixFdSuccesfully)
+{
+    auto resUnixFd = m_proxy->getUnixFd();
+    ASSERT_THAT(resUnixFd.get(), Gt(UNIX_FD_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithComplexTypeSuccesfully)
+{
+    auto resComplex = m_proxy->getComplex();
+    ASSERT_THAT(resComplex.count(0), Eq(1));
+}
+
+TEST_F(SdbusTestObject, CallsMultiplyMethodWithNoReplyFlag)
+{
+    m_proxy->multiplyWithNoReply(INT64_VALUE, DOUBLE_VALUE);
+
+    ASSERT_TRUE(waitUntil(m_adaptor->m_wasMultiplyCalled));
+    ASSERT_THAT(m_adaptor->m_multiplyResult, Eq(INT64_VALUE * DOUBLE_VALUE));
+}
+
+TEST_F(SdbusTestObject, CallsMethodWithCustomTimeoutSuccessfully)
+{
+    auto res = m_proxy->doOperationWithTimeout(500ms, 20); // The operation will take 20ms, but the timeout is 500ms, so we are fine
+    ASSERT_THAT(res, Eq(20));
+}
+
+TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenMethodTimesOut)
+{
+    auto start = std::chrono::steady_clock::now();
+    try
+    {
+        m_proxy->doOperationWithTimeout(1us, 1000); // The operation will take 1s, but the timeout is 1us, so we should time out
+        FAIL() << "Expected sdbus::Error exception";
+    }
+    catch (const sdbus::Error& e)
+    {
+        ASSERT_THAT(e.getName(), AnyOf("org.freedesktop.DBus.Error.Timeout", "org.freedesktop.DBus.Error.NoReply"));
+        ASSERT_THAT(e.getMessage(), AnyOf("Connection timed out", "Method call timed out"));
+        auto measuredTimeout = std::chrono::steady_clock::now() - start;
+        ASSERT_THAT(measuredTimeout, Le(50ms));
+    }
+    catch(...)
+    {
+        FAIL() << "Expected sdbus::Error exception";
+    }
+}
+
+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());
+
+    ASSERT_TRUE(waitUntil(m_adaptor->m_wasThrowErrorCalled));
+}
+
+TEST_F(SdbusTestObject, FailsCallingNonexistentMethod)
+{
+    ASSERT_THROW(m_proxy->callNonexistentMethod(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentInterface)
+{
+    ASSERT_THROW(m_proxy->callMethodOnNonexistentInterface(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentDestination)
+{
+    TestProxy proxy("sdbuscpp.destination.that.does.not.exist", OBJECT_PATH);
+    ASSERT_THROW(proxy.getInt(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentObject)
+{
+    TestProxy proxy(BUS_NAME, "/sdbuscpp/path/that/does/not/exist");
+    ASSERT_THROW(proxy.getInt(), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, CanReceiveSignalWhileMakingMethodCall)
+{
+    m_proxy->emitTwoSimpleSignals();
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithMap));
+}
+
+TEST_F(SdbusTestObject, CanAccessAssociatedMethodCallMessageInMethodCallHandler)
+{
+    m_proxy->doOperation(10); // This will save pointer to method call message on server side
+
+    ASSERT_THAT(m_adaptor->m_methodCallMsg, NotNull());
+    ASSERT_THAT(m_adaptor->m_methodCallMemberName, Eq("doOperation"));
+}
+
+TEST_F(SdbusTestObject, CanAccessAssociatedMethodCallMessageInAsyncMethodCallHandler)
+{
+    m_proxy->doOperationAsync(10); // This will save pointer to method call message on server side
+
+    ASSERT_THAT(m_adaptor->m_methodCallMsg, NotNull());
+    ASSERT_THAT(m_adaptor->m_methodCallMemberName, Eq("doOperationAsync"));
+}
+
+#if LIBSYSTEMD_VERSION>=240
+TEST_F(SdbusTestObject, CanSetGeneralMethodTimeoutWithLibsystemdVersionGreaterThan239)
+{
+    s_adaptorConnection->setMethodCallTimeout(5000000);
+    ASSERT_THAT(s_adaptorConnection->getMethodCallTimeout(), Eq(5000000));
+}
+#else
+TEST_F(SdbusTestObject, CannotSetGeneralMethodTimeoutWithLibsystemdVersionLessThan240)
+{
+    ASSERT_THROW(s_adaptorConnection->setMethodCallTimeout(5000000), sdbus::Error);
+    ASSERT_THROW(s_adaptorConnection->getMethodCallTimeout(), sdbus::Error);
+}
+#endif

tests/integrationtests/DBusPropertiesTests.cpp

@@ -0,0 +1,85 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file DBusPropertiesTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using ::testing::NotNull;
+using ::testing::Not;
+using ::testing::IsEmpty;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, ReadsReadOnlyPropertySuccesfully)
+{
+    ASSERT_THAT(m_proxy->state(), Eq(DEFAULT_STATE_VALUE));
+}
+
+TEST_F(SdbusTestObject, FailsWritingToReadOnlyProperty)
+{
+    ASSERT_THROW(m_proxy->setStateProperty("new_value"), sdbus::Error);
+}
+
+TEST_F(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
+{
+    uint32_t newActionValue = 5678;
+
+    m_proxy->action(newActionValue);
+
+    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+}
+
+TEST_F(SdbusTestObject, CanAccessAssociatedPropertySetMessageInPropertySetHandler)
+{
+    m_proxy->blocking(true); // This will save pointer to property get message on server side
+
+    ASSERT_THAT(m_adaptor->m_propertySetMsg, NotNull());
+    ASSERT_THAT(m_adaptor->m_propertySetSender, Not(IsEmpty()));
+}

tests/integrationtests/DBusSignalsTests.cpp

@@ -0,0 +1,157 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file AdaptorAndProxy_test.cpp
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <chrono>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using ::testing::NotNull;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, EmitsSimpleSignalSuccesfully)
+{
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+}
+
+TEST_F(SdbusTestObject, EmitsSimpleSignalToMultipleProxiesSuccesfully)
+{
+    auto proxy1 = std::make_unique<TestProxy>(*s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestProxy>(*s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(proxy1->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(proxy2->m_gotSimpleSignal));
+}
+
+TEST_F(SdbusTestObject, ProxyDoesNotReceiveSignalFromOtherBusName)
+{
+    auto otherBusName = BUS_NAME + "2";
+    auto connection2 = sdbus::createConnection(otherBusName);
+    auto adaptor2 = std::make_unique<TestAdaptor>(*connection2, OBJECT_PATH);
+
+    adaptor2->emitSimpleSignal();
+
+    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, 2s));
+}
+
+TEST_F(SdbusTestObject, EmitsSignalWithMapSuccesfully)
+{
+    m_adaptor->emitSignalWithMap({{0, "zero"}, {1, "one"}});
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithMap));
+    ASSERT_THAT(m_proxy->m_mapFromSignal[0], Eq("zero"));
+    ASSERT_THAT(m_proxy->m_mapFromSignal[1], Eq("one"));
+}
+
+TEST_F(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
+{
+    double d = 3.14;
+    m_adaptor->emitSignalWithVariant(d);
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithVariant));
+    ASSERT_THAT(m_proxy->m_variantFromSignal, DoubleEq(d));
+}
+
+TEST_F(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
+{
+    m_adaptor->emitSignalWithoutRegistration({"platform", {"av"}});
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithSignature));
+    ASSERT_THAT(m_proxy->m_signatureFromSignal["platform"], Eq("av"));
+}
+
+TEST_F(SdbusTestObject, CanAccessAssociatedSignalMessageInSignalHandler)
+{
+    m_adaptor->emitSimpleSignal();
+
+    waitUntil(m_proxy->m_gotSimpleSignal);
+
+    ASSERT_THAT(m_proxy->m_signalMsg, NotNull());
+    ASSERT_THAT(m_proxy->m_signalMemberName, Eq("simpleSignal"));
+}
+
+TEST_F(SdbusTestObject, UnregistersSignalHandler)
+{
+    ASSERT_NO_THROW(m_proxy->unregisterSimpleSignalHandler());
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, 2s));
+}
+
+TEST_F(SdbusTestObject, UnregistersSignalHandlerForSomeProxies)
+{
+    auto proxy1 = std::make_unique<TestProxy>(*s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestProxy>(*s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+
+    ASSERT_NO_THROW(m_proxy->unregisterSimpleSignalHandler());
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(proxy1->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(proxy2->m_gotSimpleSignal));
+    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, 2s));
+}
+
+TEST_F(SdbusTestObject, ReRegistersSignalHandler)
+{
+    // unregister simple-signal handler
+    ASSERT_NO_THROW(m_proxy->unregisterSimpleSignalHandler());
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, 2s));
+
+    // re-register simple-signal handler
+    ASSERT_NO_THROW(m_proxy->reRegisterSimpleSignalHandler());
+
+    m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+}

tests/integrationtests/DBusStandardInterfacesTests.cpp

@@ -0,0 +1,258 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file DBusStandardInterfacesTests.cpp
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "TestFixture.h"
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "sdbus-c++/sdbus-c++.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <string>
+#include <thread>
+#include <tuple>
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <unistd.h>
+
+using ::testing::Eq;
+using ::testing::DoubleEq;
+using ::testing::Gt;
+using ::testing::AnyOf;
+using ::testing::ElementsAre;
+using ::testing::SizeIs;
+using namespace std::chrono_literals;
+using namespace sdbus::test;
+
+using SdbusTestObject = TestFixture;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST_F(SdbusTestObject, PingsViaPeerInterface)
+{
+    ASSERT_NO_THROW(m_proxy->Ping());
+}
+
+TEST_F(SdbusTestObject, AnswersMachineUuidViaPeerInterface)
+{
+    // If /etc/machine-id does not exist in your system (which is very likely because you have
+    // a non-systemd Linux), org.freedesktop.DBus.Peer.GetMachineId() will not work. To solve
+    // this, you can create /etc/machine-id yourself as symlink to /var/lib/dbus/machine-id,
+    // and then org.freedesktop.DBus.Peer.GetMachineId() will start to work.
+    if (::access("/etc/machine-id", F_OK) == -1)
+        GTEST_SKIP() << "/etc/machine-id file does not exist, GetMachineId() will not work";
+
+    ASSERT_NO_THROW(m_proxy->GetMachineId());
+}
+
+// TODO: Adjust expected xml and uncomment this test
+//TEST_F(SdbusTestObject, AnswersXmlApiDescriptionViaIntrospectableInterface)
+//{
+//    ASSERT_THAT(m_proxy->Introspect(), Eq(m_adaptor->getExpectedXmlApiDescription()));
+//}
+
+TEST_F(SdbusTestObject, GetsPropertyViaPropertiesInterface)
+{
+    ASSERT_THAT(m_proxy->Get(INTERFACE_NAME, "state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+}
+
+TEST_F(SdbusTestObject, SetsPropertyViaPropertiesInterface)
+{
+    uint32_t newActionValue = 2345;
+
+    m_proxy->Set(INTERFACE_NAME, "action", newActionValue);
+
+    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+}
+
+TEST_F(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
+{
+    const auto properties = m_proxy->GetAll(INTERFACE_NAME);
+
+    ASSERT_THAT(properties, SizeIs(3));
+    EXPECT_THAT(properties.at("state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    EXPECT_THAT(properties.at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(properties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+}
+
+TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
+{
+    std::atomic<bool> signalReceived{false};
+    m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const std::string& interfaceName
+                                                             , const std::map<std::string, sdbus::Variant>& changedProperties
+                                                             , const std::vector<std::string>& /*invalidatedProperties*/ )
+    {
+        EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
+        EXPECT_THAT(changedProperties, SizeIs(1));
+        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(!DEFAULT_BLOCKING_VALUE));
+        signalReceived = true;
+    };
+
+    m_proxy->blocking(!DEFAULT_BLOCKING_VALUE);
+    m_proxy->action(DEFAULT_ACTION_VALUE*2);
+    m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME, {"blocking"});
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForAllProperties)
+{
+    std::atomic<bool> signalReceived{false};
+    m_proxy->m_onPropertiesChangedHandler = [&signalReceived]( const std::string& interfaceName
+                                                             , const std::map<std::string, sdbus::Variant>& changedProperties
+                                                             , const std::vector<std::string>& invalidatedProperties )
+    {
+        EXPECT_THAT(interfaceName, Eq(INTERFACE_NAME));
+        EXPECT_THAT(changedProperties, SizeIs(1));
+        EXPECT_THAT(changedProperties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+        ASSERT_THAT(invalidatedProperties, SizeIs(1));
+        EXPECT_THAT(invalidatedProperties[0], Eq("action"));
+        signalReceived = true;
+    };
+
+    m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME);
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, GetsZeroManagedObjectsIfHasNoSubPathObjects)
+{
+    m_adaptor.reset();
+    const auto objectsInterfacesAndProperties = m_objectManagerProxy->GetManagedObjects();
+
+    ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(0));
+}
+
+TEST_F(SdbusTestObject, GetsManagedObjectsSuccessfully)
+{
+    auto adaptor2 = std::make_unique<TestAdaptor>(*s_adaptorConnection, OBJECT_PATH_2);
+    const auto objectsInterfacesAndProperties = m_objectManagerProxy->GetManagedObjects();
+
+    ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(2));
+    EXPECT_THAT(objectsInterfacesAndProperties.at(OBJECT_PATH)
+        .at(org::sdbuscpp::integrationtests_adaptor::INTERFACE_NAME)
+        .at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(objectsInterfacesAndProperties.at(OBJECT_PATH_2)
+        .at(org::sdbuscpp::integrationtests_adaptor::INTERFACE_NAME)
+        .at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+}
+
+TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterfaces)
+{
+    std::atomic<bool> signalReceived{false};
+    m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+            , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+    {
+        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+        EXPECT_THAT(interfacesAndProperties, SizeIs(1));
+        EXPECT_THAT(interfacesAndProperties.count(INTERFACE_NAME), Eq(1));
+#if LIBSYSTEMD_VERSION<=244
+        // Up to sd-bus v244, all properties are added to the list, i.e. `state', `action', and `blocking' in this case.
+        EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(3));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("state"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("action"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("blocking"));
+#else
+        // Since v245 sd-bus does not add to the InterfacesAdded signal message the values of properties marked only
+        // for invalidation on change, which makes the behavior consistent with the PropertiesChangedSignal.
+        // So in this specific instance, `action' property is no more added to the list.
+        EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(2));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("state"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("blocking"));
+#endif
+        signalReceived = true;
+    };
+
+    m_adaptor->emitInterfacesAddedSignal({INTERFACE_NAME});
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces)
+{
+    std::atomic<bool> signalReceived{false};
+    m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+            , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+    {
+        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+        EXPECT_THAT(interfacesAndProperties, SizeIs(5)); // INTERFACE_NAME + 4 standard interfaces
+#if LIBSYSTEMD_VERSION<=244
+        // Up to sd-bus v244, all properties are added to the list, i.e. `state', `action', and `blocking' in this case.
+        EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(3));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("state"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("action"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("blocking"));
+#else
+        // Since v245 sd-bus does not add to the InterfacesAdded signal message the values of properties marked only
+        // for invalidation on change, which makes the behavior consistent with the PropertiesChangedSignal.
+        // So in this specific instance, `action' property is no more added to the list.
+        EXPECT_THAT(interfacesAndProperties.at(INTERFACE_NAME), SizeIs(2));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("state"));
+        EXPECT_TRUE(interfacesAndProperties.at(INTERFACE_NAME).count("blocking"));
+#endif
+        signalReceived = true;
+    };
+
+    m_adaptor->emitInterfacesAddedSignal();
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfaces)
+{
+    std::atomic<bool> signalReceived{false};
+    m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                                          , const std::vector<std::string>& interfaces )
+    {
+        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+        ASSERT_THAT(interfaces, SizeIs(1));
+        EXPECT_THAT(interfaces[0], Eq(INTERFACE_NAME));
+        signalReceived = true;
+    };
+
+    m_adaptor->emitInterfacesRemovedSignal({INTERFACE_NAME});
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}
+
+TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForAllObjectInterfaces)
+{
+    std::atomic<bool> signalReceived{false};
+    m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                                          , const std::vector<std::string>& interfaces )
+    {
+        EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+        ASSERT_THAT(interfaces, SizeIs(5)); // INTERFACE_NAME + 4 standard interfaces
+        signalReceived = true;
+    };
+
+    m_adaptor->emitInterfacesRemovedSignal();
+
+    ASSERT_TRUE(waitUntil(signalReceived));
+}

tests/integrationtests/Defs.h

@@ -1,8 +1,8 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
- * @file defs.h
+ * @file Defs.h
  *
  * Created on: Jan 2, 2017
  * Project: sdbus-c++
@@ -28,9 +28,16 @@
 #define SDBUS_CPP_INTEGRATIONTESTS_DEFS_H_
 
 #include "sdbus-c++/Types.h"
+#include <chrono>
+#include <ostream>
+
+namespace sdbus { namespace test {
 
 const std::string INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
-const std::string OBJECT_PATH{"/"};
+const std::string BUS_NAME = INTERFACE_NAME;
+const std::string MANAGER_PATH {"/org/sdbuscpp/integrationtests"};
+const std::string OBJECT_PATH  {"/org/sdbuscpp/integrationtests/ObjectA1"};
+const std::string OBJECT_PATH_2{"/org/sdbuscpp/integrationtests/ObjectB1"};
 
 constexpr const uint8_t UINT8_VALUE{1};
 constexpr const int16_t INT16_VALUE{21};
@@ -49,4 +56,18 @@ const bool DEFAULT_BLOCKING_VALUE{true};
 
 constexpr const double DOUBLE_VALUE{3.24L};
 
+}}
+
+namespace testing::internal {
+
+// Printer for std::chrono::duration types.
+// This is a workaround, since it's not a good thing to add this to std namespace.
+template< class Rep, class Period >
+void PrintTo(const ::std::chrono::duration<Rep, Period>& d, ::std::ostream* os) {
+    auto seconds = std::chrono::duration_cast<std::chrono::duration<double>>(d);
+    *os << seconds.count() << "s";
+}
+
+}
+
 #endif /* SDBUS_CPP_INTEGRATIONTESTS_DEFS_H_ */

tests/integrationtests/TestAdaptor.cpp

@@ -0,0 +1,426 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file TestAdaptor.cpp
+ *
+ * Created on: May 23, 2020
+ * 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 "TestAdaptor.h"
+#include <thread>
+#include <chrono>
+#include <atomic>
+
+namespace sdbus { namespace test {
+    
+TestAdaptor::TestAdaptor(sdbus::IConnection& connection, const std::string& path) :
+    AdaptorInterfaces(connection, path)
+{
+    registerAdaptor();
+}
+
+TestAdaptor::~TestAdaptor()
+{
+    unregisterAdaptor();
+}
+
+void TestAdaptor::noArgNoReturn()
+{
+}
+
+int32_t TestAdaptor::getInt()
+{
+    return INT32_VALUE;
+}
+
+std::tuple<uint32_t, std::string> TestAdaptor::getTuple()
+{
+    return std::make_tuple(UINT32_VALUE, STRING_VALUE);
+}
+
+double TestAdaptor::multiply(const int64_t& a, const double& b)
+{
+    return a * b;
+}
+
+void TestAdaptor::multiplyWithNoReply(const int64_t& a, const double& b)
+{
+    m_multiplyResult = a * b;
+    m_wasMultiplyCalled = true;
+}
+
+std::vector<int16_t> TestAdaptor::getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x)
+{
+    std::vector<int16_t> res{x.get<1>()};
+    auto y = std::get<std::vector<int16_t>>(x);
+    res.insert(res.end(), y.begin(), y.end());
+    return res;
+}
+
+sdbus::Variant TestAdaptor::processVariant(const sdbus::Variant& v)
+{
+    sdbus::Variant res = static_cast<int32_t>(v.get<double>());
+    return res;
+}
+
+std::map<int32_t, sdbus::Variant> TestAdaptor::getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y)
+{
+    std::map<int32_t, sdbus::Variant> res;
+    for (auto item : x)
+    {
+        res[item] = (item <= 0) ? std::get<0>(y) : std::get<1>(y);
+    }
+    return res;
+}
+
+sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> TestAdaptor::getStructInStruct()
+{
+    return sdbus::make_struct(STRING_VALUE, sdbus::make_struct(std::map<int32_t, int32_t>{{INT32_VALUE, INT32_VALUE}}));
+}
+
+int32_t TestAdaptor::sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b)
+{
+    int32_t res{0};
+    res += std::get<0>(a) + std::get<1>(a);
+    res += std::get<0>(b) + std::get<1>(b);
+    return res;
+}
+
+uint32_t TestAdaptor::sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b)
+{
+    uint32_t res{0};
+    for (auto x : a)
+    {
+        res += x;
+    }
+    for (auto x : b)
+    {
+        res += x;
+    }
+    return res;
+}
+
+uint32_t TestAdaptor::doOperation(const uint32_t& param)
+{
+    std::this_thread::sleep_for(std::chrono::milliseconds(param));
+
+    m_methodCallMsg = getObject().getCurrentlyProcessedMessage();
+    m_methodCallMemberName = m_methodCallMsg->getMemberName();
+
+    return param;
+}
+
+void TestAdaptor::doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t param)
+{
+    m_methodCallMsg = getObject().getCurrentlyProcessedMessage();
+    m_methodCallMemberName = m_methodCallMsg->getMemberName();
+
+    if (param == 0)
+    {
+        // Don't sleep and return the result from this thread
+        result.returnResults(param);
+    }
+    else
+    {
+        // Process asynchronously in another thread and return the result from there
+        std::thread([param, result = std::move(result)]()
+        {
+            std::this_thread::sleep_for(std::chrono::milliseconds(param));
+            result.returnResults(param);
+        }).detach();
+    }
+}
+
+sdbus::Signature TestAdaptor::getSignature()
+{
+    return SIGNATURE_VALUE;
+}
+sdbus::ObjectPath TestAdaptor::getObjPath()
+{
+    return OBJECT_PATH_VALUE;
+}
+sdbus::UnixFd TestAdaptor::getUnixFd()
+{
+    return sdbus::UnixFd{UNIX_FD_VALUE};
+}
+
+std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> TestAdaptor::getComplex()
+{
+    return { // map
+        {
+            0,  // uint_64_t
+            {   // struct
+                {   // map
+                    {
+                        23,  // uint8_t
+                        {   // vector
+                            {   // struct
+                                    "/object/path", // object path
+                                    false,
+                                    Variant{3.14},
+                                    {   // map
+                                        {0, "zero"}
+                                    }
+                            }
+                        }
+                    }
+                },
+                "a{t(a{ya(obva{is})}gs)}", // signature
+                std::string{}
+            }
+        }
+    };
+}
+
+void TestAdaptor::throwError()
+{
+    m_wasThrowErrorCalled = true;
+    throw sdbus::createError(1, "A test error occurred");
+}
+
+void TestAdaptor::throwErrorWithNoReply()
+{
+    TestAdaptor::throwError();
+}
+
+void TestAdaptor::doPrivilegedStuff()
+{
+    // Intentionally left blank
+}
+
+void TestAdaptor::emitTwoSimpleSignals()
+{
+    emitSimpleSignal();
+    emitSignalWithMap({});
+}
+
+std::string TestAdaptor::state()
+{
+    return m_state;
+}
+
+uint32_t TestAdaptor::action()
+{
+    return m_action;
+}
+
+void TestAdaptor::action(const uint32_t& value)
+{
+    m_action = value;
+}
+
+bool TestAdaptor::blocking()
+{
+    return m_blocking;
+}
+
+void TestAdaptor::blocking(const bool& value)
+{
+    m_propertySetMsg = getObject().getCurrentlyProcessedMessage();
+    m_propertySetSender = m_propertySetMsg->getSender();
+
+    m_blocking = value;
+}
+
+void TestAdaptor::emitSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
+{
+    getObject().emitSignal("signalWithoutRegistration").onInterface(sdbus::test::INTERFACE_NAME).withArguments(s);
+}
+
+std::string TestAdaptor::getExpectedXmlApiDescription() const
+{
+    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="org.freedesktop.DBus.ObjectManager">
+<method name="GetManagedObjects">
+<arg type="a{oa{sa{sv}}}" name="object_paths_interfaces_and_properties" direction="out"/>
+</method>
+<signal name="InterfacesAdded">
+<arg type="o" name="object_path"/>
+<arg type="a{sa{sv}}" name="interfaces_and_properties"/>
+</signal>
+<signal name="InterfacesRemoved">
+<arg type="o" name="object_path"/>
+<arg type="as" name="interfaces"/>
+</signal>
+</interface>
+<interface name="org.sdbuscpp.integrationtests">
+<annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
+<method name="doOperation">
+<arg type="u" direction="in"/>
+<arg type="u" direction="out"/>
+</method>
+<method name="doOperationAsync">
+<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="emitTwoSimpleSignals">
+</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">)delimiter"
+#if LIBSYSTEMD_VERSION>=242
+R"delimiter(
+<arg type="i" name="anInt" direction="out"/>)delimiter"
+#else
+R"delimiter(
+<arg type="i" direction="out"/>)delimiter"
+#endif
+R"delimiter(
+</method>
+<method name="getInts16FromStruct">
+<arg type="(yndsan)" direction="in"/>
+<arg type="an" direction="out"/>
+</method>
+<method name="getMapOfVariants">)delimiter"
+#if LIBSYSTEMD_VERSION>=242
+R"delimiter(
+<arg type="ai" name="x" direction="in"/>
+<arg type="(vv)" name="y" direction="in"/>
+<arg type="a{iv}" name="aMapOfVariants" direction="out"/>)delimiter"
+#else
+R"delimiter(
+<arg type="ai" direction="in"/>
+<arg type="(vv)" direction="in"/>
+<arg type="a{iv}" direction="out"/>)delimiter"
+#endif
+R"delimiter(
+</method>
+<method name="getObjPath">
+<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="getUnixFd">
+<arg type="h" direction="out"/>
+</method>
+<method name="multiply">)delimiter"
+#if LIBSYSTEMD_VERSION>=242
+R"delimiter(
+<arg type="x" name="a" direction="in"/>
+<arg type="d" name="b" direction="in"/>
+<arg type="d" name="result" direction="out"/>)delimiter"
+#else
+R"delimiter(
+<arg type="x" direction="in"/>
+<arg type="d" direction="in"/>
+<arg type="d" direction="out"/>)delimiter"
+#endif
+R"delimiter(
+</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="invalidates"/>
+</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";
+}
+
+}}

tests/integrationtests/TestAdaptor.h

@@ -0,0 +1,114 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file TestAdaptor.h
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CPP_INTEGRATIONTESTS_TESTADAPTOR_H_
+#define SDBUS_CPP_INTEGRATIONTESTS_TESTADAPTOR_H_
+
+#include "integrationtests-adaptor.h"
+#include "Defs.h"
+#include <thread>
+#include <chrono>
+#include <atomic>
+#include <utility>
+
+namespace sdbus { namespace test {
+
+class ObjectManagerTestAdaptor final : public sdbus::AdaptorInterfaces< sdbus::ObjectManager_adaptor >
+{
+public:
+    ObjectManagerTestAdaptor(sdbus::IConnection& connection, std::string path) :
+        AdaptorInterfaces(connection, std::move(path))
+    {
+        registerAdaptor();
+    }
+
+    ~ObjectManagerTestAdaptor()
+    {
+        unregisterAdaptor();
+    }
+};
+
+class TestAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::integrationtests_adaptor
+                                                         , sdbus::Properties_adaptor
+                                                         , sdbus::ManagedObject_adaptor >
+{
+public:
+    TestAdaptor(sdbus::IConnection& connection, const std::string& path);
+    ~TestAdaptor();
+
+protected:
+    void noArgNoReturn() override;
+    int32_t getInt() override;
+    std::tuple<uint32_t, std::string> getTuple() override;
+    double multiply(const int64_t& a, const double& b) override;
+    void multiplyWithNoReply(const int64_t& a, const double& b) override;
+    std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0) override;
+    sdbus::Variant processVariant(const sdbus::Variant& variant) override;
+    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) override;
+    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() override;
+    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1) override;
+    uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1) override;
+    uint32_t doOperation(const uint32_t& arg0) override;
+    void doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t arg0) override;
+    sdbus::Signature getSignature() override;
+    sdbus::ObjectPath getObjPath() override;
+    sdbus::UnixFd getUnixFd() override;
+    std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() override;
+    void throwError() override;
+    void throwErrorWithNoReply() override;
+    void doPrivilegedStuff() override;
+    void emitTwoSimpleSignals() override;
+
+    uint32_t action() override;
+    void action(const uint32_t& value) override;
+    bool blocking() override;
+    void blocking(const bool& value) override;
+    std::string state() override;
+
+public:
+    void emitSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s);
+    std::string getExpectedXmlApiDescription() const;
+
+private:
+    const std::string m_state{DEFAULT_STATE_VALUE};
+    uint32_t m_action{DEFAULT_ACTION_VALUE};
+    bool m_blocking{DEFAULT_BLOCKING_VALUE};
+
+public: // for tests
+    // For dont-expect-reply method call verifications
+    mutable std::atomic<bool> m_wasMultiplyCalled{false};
+    mutable double m_multiplyResult{};
+    mutable std::atomic<bool> m_wasThrowErrorCalled{false};
+
+    const Message* m_methodCallMsg{};
+    std::string m_methodCallMemberName;
+    const Message* m_propertySetMsg{};
+    std::string m_propertySetSender;
+};
+
+}}
+
+#endif /* INTEGRATIONTESTS_TESTADAPTOR_H_ */

tests/integrationtests/TestFixture.cpp

@@ -0,0 +1,34 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file TestAdaptor.cpp
+ *
+ * Created on: May 23, 2020
+ * 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 "TestFixture.h"
+
+namespace sdbus { namespace test {
+    
+std::unique_ptr<sdbus::IConnection> TestFixture::s_adaptorConnection = sdbus::createSystemBusConnection();
+std::unique_ptr<sdbus::IConnection> TestFixture::s_proxyConnection = sdbus::createSystemBusConnection();
+
+}}

tests/integrationtests/TestFixture.h

@@ -0,0 +1,111 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file TestAdaptor.h
+ *
+ * Created on: Jan 2, 2017
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CPP_INTEGRATIONTESTS_TESTFIXTURE_H_
+#define SDBUS_CPP_INTEGRATIONTESTS_TESTFIXTURE_H_
+
+#include "TestAdaptor.h"
+#include "TestProxy.h"
+#include "Defs.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include <thread>
+#include <chrono>
+#include <atomic>
+#include <chrono>
+
+namespace sdbus { namespace test {
+
+class TestFixture : public ::testing::Test
+{
+public:
+    static void SetUpTestCase()
+    {
+        s_proxyConnection->enterEventLoopAsync();
+        s_adaptorConnection->requestName(BUS_NAME);
+        s_adaptorConnection->enterEventLoopAsync();
+        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // Give time for the proxy connection to start listening to signals
+    }
+
+    static void TearDownTestCase()
+    {
+        s_adaptorConnection->releaseName(BUS_NAME);
+        s_adaptorConnection->leaveEventLoop();
+        s_proxyConnection->leaveEventLoop();
+    }
+
+    template <typename _Fnc>
+    static bool waitUntil(_Fnc&& fnc, std::chrono::milliseconds timeout = std::chrono::seconds(5))
+    {
+        using namespace std::chrono_literals;
+
+        std::chrono::milliseconds elapsed{};
+        std::chrono::milliseconds step{5ms};
+        do {
+            std::this_thread::sleep_for(step);
+            elapsed += step;
+            if (elapsed > timeout)
+                return false;
+        } while (!fnc());
+
+        return true;
+    }
+
+    static bool waitUntil(std::atomic<bool>& flag, std::chrono::milliseconds timeout = std::chrono::seconds(5))
+    {
+        return waitUntil([&flag]() -> bool { return flag; }, timeout);
+    }
+
+private:
+    void SetUp() override
+    {
+        m_objectManagerProxy = std::make_unique<ObjectManagerTestProxy>(*s_proxyConnection, BUS_NAME, MANAGER_PATH);
+        m_proxy = std::make_unique<TestProxy>(*s_proxyConnection, BUS_NAME, OBJECT_PATH);
+
+        m_objectManagerAdaptor = std::make_unique<ObjectManagerTestAdaptor>(*s_adaptorConnection, MANAGER_PATH);
+        m_adaptor = std::make_unique<TestAdaptor>(*s_adaptorConnection, OBJECT_PATH);
+    }
+
+    void TearDown() override
+    {
+        m_proxy.reset();
+        m_adaptor.reset();
+    }
+
+public:
+    static std::unique_ptr<sdbus::IConnection> s_adaptorConnection;
+    static std::unique_ptr<sdbus::IConnection> s_proxyConnection;
+    std::unique_ptr<ObjectManagerTestAdaptor> m_objectManagerAdaptor;
+    std::unique_ptr<ObjectManagerTestProxy> m_objectManagerProxy;
+    std::unique_ptr<TestAdaptor> m_adaptor;
+    std::unique_ptr<TestProxy> m_proxy;
+};
+
+}}
+
+#endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTFIXTURE_H_ */

tests/integrationtests/TestProxy.cpp

@@ -0,0 +1,161 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file TestAdaptor.cpp
+ *
+ * Created on: May 23, 2020
+ * 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 "TestProxy.h"
+#include <thread>
+#include <chrono>
+#include <atomic>
+
+namespace sdbus { namespace test {
+    
+TestProxy::TestProxy(std::string destination, std::string objectPath)
+    : ProxyInterfaces(std::move(destination), std::move(objectPath))
+{
+    getProxy().uponSignal("signalWithoutRegistration").onInterface(sdbus::test::INTERFACE_NAME).call([this](const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s){ this->onSignalWithoutRegistration(s); });
+
+    registerProxy();
+}
+
+TestProxy::TestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
+    : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
+{
+    getProxy().uponSignal("signalWithoutRegistration").onInterface(sdbus::test::INTERFACE_NAME).call([this](const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s){ this->onSignalWithoutRegistration(s); });
+
+    registerProxy();
+}
+
+TestProxy::~TestProxy()
+{
+    unregisterProxy();
+}
+
+void TestProxy::onSimpleSignal()
+{
+    m_signalMsg = getProxy().getCurrentlyProcessedMessage();
+    m_signalMemberName = m_signalMsg->getMemberName();
+
+    m_gotSimpleSignal = true;
+}
+
+void TestProxy::onSignalWithMap(const std::map<int32_t, std::string>& aMap)
+{
+    m_mapFromSignal = aMap;
+    m_gotSignalWithMap = true;
+}
+
+void TestProxy::onSignalWithVariant(const sdbus::Variant& aVariant)
+{
+    m_variantFromSignal = aVariant.get<double>();
+    m_gotSignalWithVariant = true;
+}
+
+void TestProxy::onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
+{
+    m_signatureFromSignal[std::get<0>(s)] = static_cast<std::string>(std::get<0>(std::get<1>(s)));
+    m_gotSignalWithSignature = true;
+}
+
+void TestProxy::onDoOperationReply(uint32_t returnValue, const sdbus::Error* error)
+{
+    if (m_DoOperationClientSideAsyncReplyHandler)
+        m_DoOperationClientSideAsyncReplyHandler(returnValue, error);
+}
+
+void TestProxy::onPropertiesChanged( const std::string& interfaceName
+                                   , const std::map<std::string, sdbus::Variant>& changedProperties
+                                   , const std::vector<std::string>& invalidatedProperties )
+{
+    if (m_onPropertiesChangedHandler)
+        m_onPropertiesChangedHandler(interfaceName, changedProperties, invalidatedProperties);
+}
+
+void TestProxy::installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler)
+{
+    m_DoOperationClientSideAsyncReplyHandler = std::move(handler);
+}
+
+uint32_t TestProxy::doOperationWithTimeout(const std::chrono::microseconds &timeout, uint32_t param)
+{
+    using namespace std::chrono_literals;
+    uint32_t result;
+    getProxy().callMethod("doOperation").onInterface(sdbus::test::INTERFACE_NAME).withTimeout(timeout).withArguments(param).storeResultsTo(result);
+    return result;
+}
+
+sdbus::PendingAsyncCall TestProxy::doOperationClientSideAsync(uint32_t param)
+{
+    return getProxy().callMethodAsync("doOperation")
+                     .onInterface(sdbus::test::INTERFACE_NAME)
+                     .withArguments(param)
+                     .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
+                                      {
+                                          this->onDoOperationReply(returnValue, error);
+                                      });
+}
+
+void TestProxy::doErroneousOperationClientSideAsync()
+{
+    getProxy().callMethodAsync("throwError")
+              .onInterface(sdbus::test::INTERFACE_NAME)
+              .uponReplyInvoke([this](const sdbus::Error* error)
+                               {
+                                   this->onDoOperationReply(0, error);
+                               });
+}
+
+void TestProxy::doOperationClientSideAsyncWithTimeout(const std::chrono::microseconds &timeout, uint32_t param)
+{
+    using namespace std::chrono_literals;
+    getProxy().callMethodAsync("doOperation")
+              .onInterface(sdbus::test::INTERFACE_NAME)
+              .withTimeout(timeout)
+              .withArguments(param)
+              .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
+                               {
+                                   this->onDoOperationReply(returnValue, error);
+                               });
+}
+
+int32_t TestProxy::callNonexistentMethod()
+{
+    int32_t result;
+    getProxy().callMethod("callNonexistentMethod").onInterface(sdbus::test::INTERFACE_NAME).storeResultsTo(result);
+    return result;
+}
+
+int32_t TestProxy::callMethodOnNonexistentInterface()
+{
+    int32_t result;
+    getProxy().callMethod("someMethod").onInterface("sdbuscpp.interface.that.does.not.exist").storeResultsTo(result);
+    return result;
+}
+
+void TestProxy::setStateProperty(const std::string& value)
+{
+    getProxy().setProperty("state").onInterface(sdbus::test::INTERFACE_NAME).toValue(value);
+}
+
+}}

tests/integrationtests/TestProxy.h

@@ -1,8 +1,8 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
- * @file TestingProxy.h
+ * @file TestAdaptor.h
  *
  * Created on: Jan 2, 2017
  * Project: sdbus-c++
@@ -24,88 +24,81 @@
  * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_
+#ifndef SDBUS_CPP_INTEGRATIONTESTS_TESTPROXY_H_
+#define SDBUS_CPP_INTEGRATIONTESTS_TESTPROXY_H_
 
-#include "proxy-glue.h"
+#include "integrationtests-proxy.h"
+#include "Defs.h"
+#include <thread>
+#include <chrono>
 #include <atomic>
 
-class TestingProxy : public sdbus::ProxyInterfaces< ::testing_proxy
-                                                  , sdbus::Peer_proxy
-                                                  , sdbus::Introspectable_proxy
-                                                  , sdbus::Properties_proxy
-                                                  , sdbus::ObjectManager_proxy >
+namespace sdbus { namespace test {
+
+class ObjectManagerTestProxy final : public sdbus::ProxyInterfaces< sdbus::ObjectManager_proxy >
 {
 public:
-    TestingProxy(std::string destination, std::string objectPath)
-        : ProxyInterfaces(std::move(destination), std::move(objectPath))
+    ObjectManagerTestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
+        : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
     {
         registerProxy();
     }
 
-    ~TestingProxy()
+    ~ObjectManagerTestProxy()
     {
         unregisterProxy();
     }
-
-    void installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler)
-    {
-        m_DoOperationClientSideAsyncReplyHandler = handler;
-    }
-
 protected:
-    void onSimpleSignal() override
-    {
-        m_gotSimpleSignal = true;
-    }
-
-    void onSignalWithMap(const std::map<int32_t, std::string>& m) override
-    {
-        m_mapFromSignal = m;
-        m_gotSignalWithMap = true;
-    }
-
-    void onSignalWithVariant(const sdbus::Variant& v) override
-    {
-        m_variantFromSignal = v.get<double>();
-        m_gotSignalWithVariant = true;
-    }
-
-    void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s) override
-    {
-        m_signatureFromSignal[std::get<0>(s)] = static_cast<std::string>(std::get<0>(std::get<1>(s)));
-        m_gotSignalWithSignature = true;
-    }
-
-    void onDoOperationReply(uint32_t returnValue, const sdbus::Error* error) override
-    {
-        if (m_DoOperationClientSideAsyncReplyHandler)
-            m_DoOperationClientSideAsyncReplyHandler(returnValue, error);
-    }
-
-    // Signals of standard D-Bus interfaces
-
-    void onPropertiesChanged( const std::string& interfaceName
-                            , const std::map<std::string, sdbus::Variant>& changedProperties
-                            , const std::vector<std::string>& invalidatedProperties ) override
-    {
-        if (m_onPropertiesChangedHandler)
-            m_onPropertiesChangedHandler(interfaceName, changedProperties, invalidatedProperties);
-    }
-
-    void onInterfacesAdded( const sdbus::ObjectPath& objectPath
-                          , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties) override
+    void onInterfacesAdded(const sdbus::ObjectPath& objectPath, const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties) override
     {
         if (m_onInterfacesAddedHandler)
             m_onInterfacesAddedHandler(objectPath, interfacesAndProperties);
     }
-    void onInterfacesRemoved( const sdbus::ObjectPath& objectPath
-                            , const std::vector<std::string>& interfaces) override
+
+    void onInterfacesRemoved(const sdbus::ObjectPath& objectPath, const std::vector<std::string>& interfaces) override
     {
         if (m_onInterfacesRemovedHandler)
             m_onInterfacesRemovedHandler(objectPath, interfaces);
     }
 
+public: // for tests
+    std::function<void(const sdbus::ObjectPath&, const std::map<std::string, std::map<std::string, sdbus::Variant>>&)> m_onInterfacesAddedHandler;
+    std::function<void(const sdbus::ObjectPath&, const std::vector<std::string>&)> m_onInterfacesRemovedHandler;
+};
+
+class TestProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::integrationtests_proxy
+                                                     , sdbus::Peer_proxy
+                                                     , sdbus::Introspectable_proxy
+                                                     , sdbus::Properties_proxy >
+{
+public:
+    TestProxy(std::string destination, std::string objectPath);
+    TestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath);
+    ~TestProxy();
+
+protected:
+    void onSimpleSignal() override;
+    void onSignalWithMap(const std::map<int32_t, std::string>& aMap) override;
+    void onSignalWithVariant(const sdbus::Variant& aVariant) override;
+
+    void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s);
+    void onDoOperationReply(uint32_t returnValue, const sdbus::Error* error);
+
+    // Signals of standard D-Bus interfaces
+    void onPropertiesChanged( const std::string& interfaceName
+                            , const std::map<std::string, sdbus::Variant>& changedProperties
+                            , const std::vector<std::string>& invalidatedProperties ) override;
+
+public:
+    void installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler);
+    uint32_t doOperationWithTimeout(const std::chrono::microseconds &timeout, uint32_t param);
+    sdbus::PendingAsyncCall doOperationClientSideAsync(uint32_t param);
+    void doErroneousOperationClientSideAsync();
+    void doOperationClientSideAsyncWithTimeout(const std::chrono::microseconds &timeout, uint32_t param);
+    int32_t callNonexistentMethod();
+    int32_t callMethodOnNonexistentInterface();
+    void setStateProperty(const std::string& value);
+
 //private:
 public: // for tests
     int m_SimpleSignals = 0;
@@ -119,8 +112,11 @@ public: // for tests
 
     std::function<void(uint32_t res, const sdbus::Error* err)> m_DoOperationClientSideAsyncReplyHandler;
     std::function<void(const std::string&, const std::map<std::string, sdbus::Variant>&, const std::vector<std::string>&)> m_onPropertiesChangedHandler;
-    std::function<void(const sdbus::ObjectPath&, const std::map<std::string, std::map<std::string, sdbus::Variant>>&)> m_onInterfacesAddedHandler;
-    std::function<void(const sdbus::ObjectPath&, const std::vector<std::string>&)> m_onInterfacesRemovedHandler;
+
+    const Message* m_signalMsg{};
+    std::string m_signalMemberName;
 };
 
-#endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_ */
+}}
+
+#endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTPROXY_H_ */

tests/integrationtests/TestingAdaptor.h

@@ -1,246 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file TestingAdaptor.h
- *
- * Created on: Jan 2, 2017
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef SDBUS_CPP_INTEGRATIONTESTS_TESTINGADAPTOR_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_TESTINGADAPTOR_H_
-
-#include "adaptor-glue.h"
-#include <thread>
-#include <chrono>
-#include <atomic>
-
-class TestingAdaptor : public sdbus::AdaptorInterfaces< testing_adaptor
-                                                      , sdbus::Properties_adaptor
-                                                      , sdbus::ObjectManager_adaptor >
-{
-public:
-    TestingAdaptor(sdbus::IConnection& connection) :
-        AdaptorInterfaces(connection, OBJECT_PATH)
-    {
-        registerAdaptor();
-    }
-
-    ~TestingAdaptor()
-    {
-        unregisterAdaptor();
-    }
-
-protected:
-
-    void noArgNoReturn() const
-    {
-    }
-
-    int32_t getInt() const
-    {
-        return INT32_VALUE;
-    }
-
-    std::tuple<uint32_t, std::string> getTuple() const
-    {
-        return std::make_tuple(UINT32_VALUE, STRING_VALUE);
-    }
-
-    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_wasMultiplyCalled = 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>()};
-        auto y = std::get<std::vector<int16_t>>(x);
-        res.insert(res.end(), y.begin(), y.end());
-        return res;
-    }
-
-    sdbus::Variant processVariant(sdbus::Variant& v)
-    {
-        sdbus::Variant res = static_cast<int32_t>(v.get<double>());
-        return res;
-    }
-
-    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) const
-    {
-        std::map<int32_t, sdbus::Variant> res;
-        for (auto item : x)
-        {
-            res[item] = (item <= 0) ? std::get<0>(y) : std::get<1>(y);
-        }
-        return res;
-    }
-
-    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() const
-    {
-        return sdbus::make_struct(STRING_VALUE, sdbus::make_struct(std::map<int32_t, int32_t>{{INT32_VALUE, INT32_VALUE}}));
-    }
-
-    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b)
-    {
-        int32_t res{0};
-        res += std::get<0>(a) + std::get<1>(a);
-        res += std::get<0>(b) + std::get<1>(b);
-        return res;
-    }
-
-    uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b)
-    {
-        uint32_t res{0};
-        for (auto x : a)
-        {
-            res += x;
-        }
-        for (auto x : b)
-        {
-            res += x;
-        }
-        return res;
-    }
-
-    uint32_t doOperation(uint32_t param)
-    {
-        std::this_thread::sleep_for(std::chrono::milliseconds(param));
-        return param;
-    }
-
-    void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result)
-    {
-        if (param == 0)
-        {
-            // Don't sleep and return the result from this thread
-            result.returnResults(param);
-        }
-        else
-        {
-            // Process asynchronously in another thread and return the result from there
-            std::thread([param, result = std::move(result)]()
-            {
-                std::this_thread::sleep_for(std::chrono::milliseconds(param));
-                result.returnResults(param);
-            }).detach();
-        }
-    }
-
-    sdbus::Signature getSignature() const
-    {
-        return SIGNATURE_VALUE;
-    }
-    sdbus::ObjectPath getObjectPath() const
-    {
-        return OBJECT_PATH_VALUE;
-    }
-    sdbus::UnixFd getUnixFd() const
-    {
-        return sdbus::UnixFd{UNIX_FD_VALUE};
-    }
-
-    ComplexType getComplex() const
-    {
-        return { // map
-            {
-                0,  // uint_64_t
-                {   // struct
-                    {   // map
-                        {
-                            'a',  // uint8_t
-                            {   // vector
-                                {   // struct
-                                        "/object/path", // object path
-                                        false,
-                                        3.14,
-                                        {   // map
-                                            {0, "zero"}
-                                        }
-                                }
-                            }
-                        }
-                    },
-                    "a{t(a{ya(obva{is})}gs)}", // signature
-                    ""
-                }
-            }
-        };
-    }
-
-    void throwError() const
-    {
-        m_wasThrowErrorCalled = true;
-        throw sdbus::createError(1, "A test error occurred");
-    }
-
-
-    void emitTwoSimpleSignals() override
-    {
-        emitSimpleSignal();
-        emitSignalWithMap({});
-    }
-
-    std::string state()
-    {
-        return m_state;
-    }
-
-    uint32_t action()
-    {
-        return m_action;
-    }
-
-    void action(const uint32_t& value)
-    {
-        m_action = value;
-    }
-
-    bool blocking()
-    {
-        return m_blocking;
-    }
-
-    void blocking(const bool& value)
-    {
-        m_blocking = value;
-    }
-
-private:
-    const std::string m_state{DEFAULT_STATE_VALUE};
-    uint32_t m_action{DEFAULT_ACTION_VALUE};
-    bool m_blocking{DEFAULT_BLOCKING_VALUE};
-
-public: // for tests
-    // For dont-expect-reply method call verifications
-    mutable std::atomic<bool> m_wasMultiplyCalled{false};
-    mutable double m_multiplyResult{};
-    mutable std::atomic<bool> m_wasThrowErrorCalled{false};
-};
-
-
-
-#endif /* INTEGRATIONTESTS_TESTINGADAPTOR_H_ */

tests/integrationtests/adaptor-glue.h

@@ -1,339 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file adaptor-glue.h
- *
- * Created on: Jan 2, 2017
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef SDBUS_CPP_INTEGRATIONTESTS_ADAPTOR_GLUE_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_ADAPTOR_GLUE_H_
-
-#include "defs.h"
-
-// sdbus
-#include "sdbus-c++/sdbus-c++.h"
-
-using ComplexType = std::map<
-                        uint64_t,
-                        sdbus::Struct<
-                            std::map<
-                                uint8_t,
-                                std::vector<
-                                    sdbus::Struct<
-                                        sdbus::ObjectPath,
-                                        bool,
-                                        sdbus::Variant,
-                                        std::map<int, std::string>
-                                    >
-                                >
-                            >,
-                            sdbus::Signature,
-                            std::string // char* leads to type and memory issues, std::string is best choice
-                        >
-                    >;
-
-class testing_adaptor
-{
-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); });
-
-        object_.registerMethod("processVariant").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Variant& v){ return this->processVariant(v); });
-
-        object_.registerMethod("getMapOfVariants").onInterface(INTERFACE_NAME).implementedAs([this](
-                const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y){ return this->getMapOfVariants(x ,y); });
-
-        object_.registerMethod("getStructInStruct").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getStructInStruct(); });
-
-        object_.registerMethod("sumStructItems").onInterface(INTERFACE_NAME).implementedAs([this](
-                const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b){
-            return this->sumStructItems(a, b);
-        });
-
-        object_.registerMethod("sumVectorItems").onInterface(INTERFACE_NAME).implementedAs([this](
-                const std::vector<uint16_t>& a, const std::vector<uint64_t>& b){
-            return this->sumVectorItems(a, b);
-        });
-
-        object_.registerMethod("doOperation").onInterface(INTERFACE_NAME).implementedAs([this](uint32_t param)
-        {
-            return this->doOperation(param);
-        });
-
-        object_.registerMethod("doOperationAsync").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<uint32_t> result, uint32_t param)
-        {
-            this->doOperationAsync(param, std::move(result));
-        });
-
-        object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getSignature(); });
-        object_.registerMethod("getObjectPath").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getObjectPath(); });
-        object_.registerMethod("getUnixFd").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getUnixFd(); });
-
-        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();
-
-        object_.registerMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME).implementedAs([this](){ this->emitTwoSimpleSignals(); });
-
-        // registration of signals is optional, it is useful because of introspection
-        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(); }).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_INVALIDATION_SIGNAL);
-        //object_.registerProperty("blocking").onInterface(INTERFACE_NAME)./*withGetter([this](){ return this->blocking(); }).*/withSetter([this](const bool& value){ this->blocking(value); });
-        object_.registerProperty("blocking").onInterface(INTERFACE_NAME).withGetter([this](){ return this->blocking(); }).withSetter([this](const bool& value){ this->blocking(value); });
-    }
-
-    ~testing_adaptor() = default;
-
-public:
-    void emitSimpleSignal()
-    {
-        object_.emitSignal("simpleSignal").onInterface(INTERFACE_NAME);
-    }
-
-    void emitSignalWithMap(const std::map<int32_t, std::string>& map)
-    {
-        object_.emitSignal("signalWithMap").onInterface(INTERFACE_NAME).withArguments(map);
-    }
-
-    void emitSignalWithVariant(const sdbus::Variant& v)
-    {
-        object_.emitSignal("signalWithVariant").onInterface(INTERFACE_NAME).withArguments(v);
-    }
-
-    void emitSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
-    {
-        object_.emitSignal("signalWithoutRegistration").onInterface(INTERFACE_NAME).withArguments(s);
-    }
-
-    void emitSignalOnNonexistentInterface()
-    {
-        object_.emitSignal("simpleSignal").onInterface("sdbuscpp.interface.that.does.not.exist");
-    }
-
-private:
-    sdbus::IObject& object_;
-
-protected:
-
-    virtual void noArgNoReturn() const  = 0;
-    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;
-    virtual sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() const = 0;
-    virtual int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b) = 0;
-    virtual uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b) = 0;
-    virtual uint32_t doOperation(uint32_t param) = 0;
-    virtual void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result) = 0;
-    virtual sdbus::Signature getSignature() const  = 0;
-    virtual sdbus::ObjectPath getObjectPath() const = 0;
-    virtual sdbus::UnixFd getUnixFd() const  = 0;
-    virtual ComplexType getComplex() const = 0;
-    virtual void throwError() const = 0;
-    virtual void emitTwoSimpleSignals() = 0;
-
-    virtual std::string state() = 0;
-    virtual uint32_t action() = 0;
-    virtual void action(const uint32_t& value) = 0;
-    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="org.freedesktop.DBus.ObjectManager">
-  <method name="GetManagedObjects">
-   <arg type="a{oa{sa{sv}}}" name="object_paths_interfaces_and_properties" direction="out"/>
-  </method>
-  <signal name="InterfacesAdded">
-   <arg type="o" name="object_path"/>
-   <arg type="a{sa{sv}}" name="interfaces_and_properties"/>
-  </signal>
-  <signal name="InterfacesRemoved">
-   <arg type="o" name="object_path"/>
-   <arg type="as" name="interfaces"/>
-  </signal>
- </interface>
- <interface name="org.sdbuscpp.integrationtests">
-  <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
-  <method name="doOperation">
-   <arg type="u" direction="in"/>
-   <arg type="u" direction="out"/>
-  </method>
-  <method name="doOperationAsync">
-   <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="emitTwoSimpleSignals">
-  </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="getUnixFd">
-   <arg type="h" 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="invalidates"/>
-  </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";
-    }
-
-};
-
-
-
-#endif /* SDBUS_CPP_INTEGRATIONTESTS_ADAPTOR_GLUE_H_ */

tests/integrationtests/files/org.sdbuscpp.integrationtests.conf

@@ -11,6 +11,9 @@
     <allow own="org.sdbuscpp.integrationtests"/>
     <allow send_destination="org.sdbuscpp.integrationtests"/>
     <allow send_interface="org.sdbuscpp.integrationtests"/>
+
+    <allow own="org.sdbuscpp.integrationtests2"/>
+    <allow send_destination="org.sdbuscpp.integrationtests2"/>
   </policy>
 
 </busconfig>

tests/integrationtests/integrationtests-adaptor.h

@@ -0,0 +1,109 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__integrationtests_adaptor_h__adaptor__H__
+#define __sdbuscpp__integrationtests_adaptor_h__adaptor__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+
+class integrationtests_adaptor
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.integrationtests";
+
+protected:
+    integrationtests_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).withOutputParamNames("anInt").implementedAs([this](){ return this->getInt(); });
+        object_.registerMethod("getTuple").onInterface(INTERFACE_NAME).withOutputParamNames("arg0", "arg1").implementedAs([this](){ return this->getTuple(); });
+        object_.registerMethod("multiply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").withOutputParamNames("result").implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); });
+        object_.registerMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").implementedAs([this](const int64_t& a, const double& b){ return this->multiplyWithNoReply(a, b); }).markAsDeprecated().withNoReply();
+        object_.registerMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0){ return this->getInts16FromStruct(arg0); });
+        object_.registerMethod("processVariant").onInterface(INTERFACE_NAME).withInputParamNames("variant").withOutputParamNames("result").implementedAs([this](const sdbus::Variant& variant){ return this->processVariant(variant); });
+        object_.registerMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withInputParamNames("x", "y").withOutputParamNames("aMapOfVariants").implementedAs([this](const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y){ return this->getMapOfVariants(x, y); });
+        object_.registerMethod("getStructInStruct").onInterface(INTERFACE_NAME).withOutputParamNames("aMapOfVariants").implementedAs([this](){ return this->getStructInStruct(); });
+        object_.registerMethod("sumStructItems").onInterface(INTERFACE_NAME).withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1){ return this->sumStructItems(arg0, arg1); });
+        object_.registerMethod("sumVectorItems").onInterface(INTERFACE_NAME).withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1){ return this->sumVectorItems(arg0, arg1); });
+        object_.registerMethod("doOperation").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const uint32_t& arg0){ return this->doOperation(arg0); });
+        object_.registerMethod("doOperationAsync").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](sdbus::Result<uint32_t>&& result, uint32_t arg0){ this->doOperationAsync(std::move(result), std::move(arg0)); });
+        object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getSignature(); });
+        object_.registerMethod("getObjPath").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getObjPath(); });
+        object_.registerMethod("getUnixFd").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getUnixFd(); });
+        object_.registerMethod("getComplex").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").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](){ return this->throwErrorWithNoReply(); }).withNoReply();
+        object_.registerMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->doPrivilegedStuff(); }).markAsPrivileged();
+        object_.registerMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->emitTwoSimpleSignals(); });
+        object_.registerSignal("simpleSignal").onInterface(INTERFACE_NAME).markAsDeprecated();
+        object_.registerSignal("signalWithMap").onInterface(INTERFACE_NAME).withParameters<std::map<int32_t, std::string>>("aMap");
+        object_.registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>("aVariant");
+        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_INVALIDATION_SIGNAL);
+        object_.registerProperty("blocking").onInterface(INTERFACE_NAME).withGetter([this](){ return this->blocking(); }).withSetter([this](const bool& value){ this->blocking(value); });
+        object_.registerProperty("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE);
+    }
+
+    ~integrationtests_adaptor() = default;
+
+public:
+    void emitSimpleSignal()
+    {
+        object_.emitSignal("simpleSignal").onInterface(INTERFACE_NAME);
+    }
+
+    void emitSignalWithMap(const std::map<int32_t, std::string>& aMap)
+    {
+        object_.emitSignal("signalWithMap").onInterface(INTERFACE_NAME).withArguments(aMap);
+    }
+
+    void emitSignalWithVariant(const sdbus::Variant& aVariant)
+    {
+        object_.emitSignal("signalWithVariant").onInterface(INTERFACE_NAME).withArguments(aVariant);
+    }
+
+private:
+    virtual void noArgNoReturn() = 0;
+    virtual int32_t getInt() = 0;
+    virtual std::tuple<uint32_t, std::string> getTuple() = 0;
+    virtual double multiply(const int64_t& a, const double& b) = 0;
+    virtual void multiplyWithNoReply(const int64_t& a, const double& b) = 0;
+    virtual std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0) = 0;
+    virtual sdbus::Variant processVariant(const sdbus::Variant& variant) = 0;
+    virtual std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) = 0;
+    virtual sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() = 0;
+    virtual int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1) = 0;
+    virtual uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1) = 0;
+    virtual uint32_t doOperation(const uint32_t& arg0) = 0;
+    virtual void doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t arg0) = 0;
+    virtual sdbus::Signature getSignature() = 0;
+    virtual sdbus::ObjectPath getObjPath() = 0;
+    virtual sdbus::UnixFd getUnixFd() = 0;
+    virtual std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() = 0;
+    virtual void throwError() = 0;
+    virtual void throwErrorWithNoReply() = 0;
+    virtual void doPrivilegedStuff() = 0;
+    virtual void emitTwoSimpleSignals() = 0;
+
+private:
+    virtual uint32_t action() = 0;
+    virtual void action(const uint32_t& value) = 0;
+    virtual bool blocking() = 0;
+    virtual void blocking(const bool& value) = 0;
+    virtual std::string state() = 0;
+
+private:
+    sdbus::IObject& object_;
+};
+
+}} // namespaces
+
+#endif

tests/integrationtests/integrationtests-proxy.h

@@ -0,0 +1,215 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__integrationtests_proxy_h__proxy__H__
+#define __sdbuscpp__integrationtests_proxy_h__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+
+class integrationtests_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.integrationtests";
+
+protected:
+    integrationtests_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
+        proxy_.uponSignal("signalWithMap").onInterface(INTERFACE_NAME).call([this](const std::map<int32_t, std::string>& aMap){ this->onSignalWithMap(aMap); });
+        proxy_.uponSignal("signalWithVariant").onInterface(INTERFACE_NAME).call([this](const sdbus::Variant& aVariant){ this->onSignalWithVariant(aVariant); });
+    }
+
+    ~integrationtests_proxy() = default;
+
+    virtual void onSimpleSignal() = 0;
+    virtual void onSignalWithMap(const std::map<int32_t, std::string>& aMap) = 0;
+    virtual void onSignalWithVariant(const sdbus::Variant& aVariant) = 0;
+
+public:
+    void noArgNoReturn()
+    {
+        proxy_.callMethod("noArgNoReturn").onInterface(INTERFACE_NAME);
+    }
+
+    int32_t getInt()
+    {
+        int32_t result;
+        proxy_.callMethod("getInt").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    std::tuple<uint32_t, std::string> getTuple()
+    {
+        std::tuple<uint32_t, std::string> result;
+        proxy_.callMethod("getTuple").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    double multiply(const int64_t& a, const double& b)
+    {
+        double result;
+        proxy_.callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
+        return result;
+    }
+
+    void multiplyWithNoReply(const int64_t& a, const double& b)
+    {
+        proxy_.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>>& arg0)
+    {
+        std::vector<int16_t> result;
+        proxy_.callMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::Variant processVariant(const sdbus::Variant& variant)
+    {
+        sdbus::Variant result;
+        proxy_.callMethod("processVariant").onInterface(INTERFACE_NAME).withArguments(variant).storeResultsTo(result);
+        return result;
+    }
+
+    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y)
+    {
+        std::map<int32_t, sdbus::Variant> result;
+        proxy_.callMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withArguments(x, y).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct()
+    {
+        sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> result;
+        proxy_.callMethod("getStructInStruct").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1)
+    {
+        int32_t result;
+        proxy_.callMethod("sumStructItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1)
+    {
+        uint32_t result;
+        proxy_.callMethod("sumVectorItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t doOperation(const uint32_t& arg0)
+    {
+        uint32_t result;
+        proxy_.callMethod("doOperation").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        return result;
+    }
+
+    uint32_t doOperationAsync(const uint32_t& arg0)
+    {
+        uint32_t result;
+        proxy_.callMethod("doOperationAsync").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::Signature getSignature()
+    {
+        sdbus::Signature result;
+        proxy_.callMethod("getSignature").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::ObjectPath getObjPath()
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("getObjPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::UnixFd getUnixFd()
+    {
+        sdbus::UnixFd result;
+        proxy_.callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex()
+    {
+        std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> result;
+        proxy_.callMethod("getComplex").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    void throwError()
+    {
+        proxy_.callMethod("throwError").onInterface(INTERFACE_NAME);
+    }
+
+    void throwErrorWithNoReply()
+    {
+        proxy_.callMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).dontExpectReply();
+    }
+
+    void doPrivilegedStuff()
+    {
+        proxy_.callMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME);
+    }
+
+    void emitTwoSimpleSignals()
+    {
+        proxy_.callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME);
+    }
+
+    void unregisterSimpleSignalHandler()
+    {
+        proxy_.muteSignal("simpleSignal").onInterface(INTERFACE_NAME);
+    }
+
+    void reRegisterSimpleSignalHandler()
+    {
+        proxy_.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
+        proxy_.finishRegistration();
+    }
+
+public:
+    uint32_t action()
+    {
+        return proxy_.getProperty("action").onInterface(INTERFACE_NAME);
+    }
+
+    void action(const uint32_t& value)
+    {
+        proxy_.setProperty("action").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    bool blocking()
+    {
+        return proxy_.getProperty("blocking").onInterface(INTERFACE_NAME);
+    }
+
+    void blocking(const bool& value)
+    {
+        proxy_.setProperty("blocking").onInterface(INTERFACE_NAME).toValue(value);
+    }
+
+    std::string state()
+    {
+        return proxy_.getProperty("state").onInterface(INTERFACE_NAME);
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}} // namespaces
+
+#endif

tests/integrationtests/org.sdbuscpp.integrationtests.xml

@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<node name="/org/sdbuscpp/integrationtest">
+    <interface name="org.sdbuscpp.integrationtests">
+        <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
+        <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="false" />
+        <method name="noArgNoReturn">
+        </method>
+        <method name="getInt">
+            <arg type="i" name="anInt" direction="out" />
+        </method>
+        <method name="getTuple">
+            <arg type="u" direction="out" />
+            <arg type="s" direction="out" />
+        </method>
+        <method name="multiply">
+            <arg type="x" name="a" direction="in" />
+            <arg type="d" name="b" direction="in" />
+            <arg type="d" name="result" direction="out" />
+        </method>
+        <method name="multiplyWithNoReply">
+            <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
+            <annotation name="org.freedesktop.DBus.Method.NoReply" value="true" />
+            <arg type="x" name="a" direction="in" />
+            <arg type="d" name="b" direction="in" />
+        </method>
+        <method name="getInts16FromStruct">
+            <arg type="(yndsan)" direction="in" />
+            <arg type="an" direction="out" />
+        </method>
+        <method name="processVariant">
+            <arg type="v" name="variant" direction="in" />
+            <arg type="v" name="result" direction="out" />
+        </method>
+        <method name="getMapOfVariants">
+            <arg type="ai" name="x" direction="in" />
+            <arg type="(vv)" name="y" direction="in" />
+            <arg type="a{iv}" name="aMapOfVariants" direction="out" />
+        </method>
+        <method name="getStructInStruct">
+            <arg type="(s(a{ii}))" name="aMapOfVariants" 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="doOperation">
+            <arg type="u" direction="in" />
+            <arg type="u" direction="out" />
+        </method>
+        <method name="doOperationAsync">
+            <annotation name="org.freedesktop.DBus.Method.Async" value="server" />
+            <arg type="u" direction="in" />
+            <arg type="u" direction="out" />
+        </method>
+        <method name="getSignature">
+            <arg type="g" direction="out" />
+        </method>
+        <method name="getObjPath">
+            <arg type="o" direction="out" />
+        </method>
+        <method name="getUnixFd">
+            <arg type="h" direction="out" />
+        </method>
+        <method name="getComplex">
+            <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
+            <arg type="a{t(a{ya(obva{is})}gs)}" direction="out" />
+        </method>
+        <method name="throwError">
+        </method>
+        <method name="throwErrorWithNoReply">
+            <annotation name="org.freedesktop.DBus.Method.NoReply" value="true" />
+        </method>
+        <method name="doPrivilegedStuff">
+            <annotation name="org.freedesktop.systemd1.Privileged" value="true" />
+        </method>
+        <method name="emitTwoSimpleSignals">
+        </method>
+        
+        <signal name="simpleSignal">
+            <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
+        </signal>
+        <signal name="signalWithMap">
+            <arg type="a{is}" name="aMap" />
+        </signal>
+        <signal name="signalWithVariant">
+            <arg type="v" name="aVariant" />
+        </signal>
+        <property name="action" type="u" access="readwrite">
+            <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="invalidates"/>
+        </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>        

tests/integrationtests/proxy-glue.h

@@ -1,282 +0,0 @@
-/**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
- *
- * @file proxy-glue.h
- *
- * Created on: Jan 2, 2017
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef SDBUS_CPP_INTEGRATIONTESTS_PROXY_GLUE_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_PROXY_GLUE_H_
-
-#include "defs.h"
-
-// sdbus
-#include "sdbus-c++/sdbus-c++.h"
-
-class testing_proxy
-{
-protected:
-    testing_proxy(sdbus::IProxy& object) :
-        object_(object)
-    {
-        object_.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
-        object_.uponSignal("signalWithMap").onInterface(INTERFACE_NAME).call([this](const std::map<int32_t, std::string>& map){ this->onSignalWithMap(map); });
-        object_.uponSignal("signalWithVariant").onInterface(INTERFACE_NAME).call([this](const sdbus::Variant& v){ this->onSignalWithVariant(v); });
-
-        object_.uponSignal("signalWithoutRegistration").onInterface(INTERFACE_NAME).call([this](const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
-                { this->onSignalWithoutRegistration(s); });
-    }
-
-    ~testing_proxy() = default;
-
-    virtual void onSimpleSignal() = 0;
-    virtual void onSignalWithMap(const std::map<int32_t, std::string>& map) = 0;
-    virtual void onSignalWithVariant(const sdbus::Variant& v) = 0;
-    virtual void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s) = 0;
-
-    virtual void onDoOperationReply(uint32_t returnValue, const sdbus::Error* error) = 0;
-
-public:
-    void emitTwoSimpleSignals()
-    {
-        object_.callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME);
-    }
-
-    void noArgNoReturn()
-    {
-        object_.callMethod("noArgNoReturn").onInterface(INTERFACE_NAME);
-    }
-
-    int32_t getInt()
-    {
-        int32_t result;
-        object_.callMethod("getInt").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    std::tuple<uint32_t, std::string> getTuple()
-    {
-        std::tuple<uint32_t, std::string> result;
-        object_.callMethod("getTuple").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    double multiply(const int64_t& a, const double& b)
-    {
-        double result;
-        object_.callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
-        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;
-        object_.callMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withArguments(x).storeResultsTo(result);
-        return result;
-     }
-
-    sdbus::Variant processVariant(const sdbus::Variant& v)
-    {
-        sdbus::Variant result;
-        object_.callMethod("processVariant").onInterface(INTERFACE_NAME).withArguments(v).storeResultsTo(result);
-        return result;
-    }
-
-    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y)
-    {
-        std::map<int32_t, sdbus::Variant> result;
-        object_.callMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withArguments(x, y).storeResultsTo(result);
-        return result;
-    }
-
-    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct()
-    {
-        sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> result;
-        object_.callMethod("getStructInStruct").onInterface(INTERFACE_NAME).withArguments().storeResultsTo(result);
-        return result;
-    }
-
-    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b)
-    {
-        int32_t result;
-        object_.callMethod("sumStructItems").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
-        return result;
-    }
-
-    uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b)
-    {
-        uint32_t result;
-        object_.callMethod("sumVectorItems").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
-        return result;
-    }
-
-    uint32_t doOperation(uint32_t param)
-    {
-        uint32_t result;
-        object_.callMethod("doOperation").onInterface(INTERFACE_NAME).withArguments(param).storeResultsTo(result);
-        return result;
-    }
-
-    uint32_t doOperationWith500msTimeout(uint32_t param)
-    {
-        using namespace std::chrono_literals;
-        uint32_t result;
-        object_.callMethod("doOperation").onInterface(INTERFACE_NAME).withTimeout(500000us).withArguments(param).storeResultsTo(result);
-        return result;
-    }
-
-    uint32_t doOperationAsync(uint32_t param)
-    {
-        uint32_t result;
-        object_.callMethod("doOperationAsync").onInterface(INTERFACE_NAME).withArguments(param).storeResultsTo(result);
-        return result;
-    }
-
-    void doOperationClientSideAsync(uint32_t param)
-    {
-        object_.callMethodAsync("doOperation")
-               .onInterface(INTERFACE_NAME)
-               .withArguments(param)
-               .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
-                                {
-                                    this->onDoOperationReply(returnValue, error);
-                                });
-    }
-
-    void doErroneousOperationClientSideAsync()
-    {
-        object_.callMethodAsync("throwError")
-               .onInterface(INTERFACE_NAME)
-               .uponReplyInvoke([this](const sdbus::Error* error)
-                                {
-                                    this->onDoOperationReply(0, error);
-                                });
-    }
-
-    void doOperationClientSideAsyncWith500msTimeout(uint32_t param)
-    {
-        using namespace std::chrono_literals;
-        object_.callMethodAsync("doOperation")
-               .onInterface(INTERFACE_NAME)
-               .withTimeout(500000us)
-               .withArguments(param)
-               .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
-                                {
-                                    this->onDoOperationReply(returnValue, error);
-                                });
-    }
-
-    sdbus::Signature getSignature()
-    {
-        sdbus::Signature result;
-        object_.callMethod("getSignature").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    sdbus::ObjectPath getObjectPath()
-    {
-        sdbus::ObjectPath result;
-        object_.callMethod("getObjectPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    sdbus::UnixFd getUnixFd()
-    {
-        sdbus::UnixFd result;
-        object_.callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    ComplexType getComplex()
-    {
-        ComplexType result;
-        object_.callMethod("getComplex").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        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;
-        object_.callMethod("callNonexistentMethod").onInterface(INTERFACE_NAME).storeResultsTo(result);
-        return result;
-    }
-
-    int32_t callMethodOnNonexistentInterface()
-    {
-        int32_t result;
-        object_.callMethod("someMethod").onInterface("sdbuscpp.interface.that.does.not.exist").storeResultsTo(result);
-        return result;
-    }
-
-    std::string state()
-    {
-        return object_.getProperty("state").onInterface(INTERFACE_NAME);
-    }
-
-    void state(const std::string& value)
-    {
-        object_.setProperty("state").onInterface(INTERFACE_NAME).toValue(value);
-    }
-
-    uint32_t action()
-    {
-        return object_.getProperty("action").onInterface(INTERFACE_NAME);
-    }
-
-    void action(const uint32_t& value)
-    {
-        object_.setProperty("action").onInterface(INTERFACE_NAME).toValue(value);
-    }
-
-    bool blocking()
-    {
-        return object_.getProperty("blocking").onInterface(INTERFACE_NAME);
-    }
-
-    void blocking(const bool& value)
-    {
-        object_.setProperty("blocking").onInterface(INTERFACE_NAME).toValue(value);
-    }
-
-
-private:
-    sdbus::IProxy& object_;
-
-};
-
-
-#endif /* SDBUS_CPP_INTEGRATIONTESTS_PROXY_GLUE_H_ */

tests/integrationtests/sdbus-c++-integration-tests.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file sdbus-c++-integration-tests.cpp
  *

tests/perftests/client.cpp

@@ -39,7 +39,7 @@ using namespace std::chrono_literals;
 
 uint64_t totalDuration = 0;
 
-class PerftestProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::perftests_proxy>
+class PerftestProxy final : public sdbus::ProxyInterfaces<org::sdbuscpp::perftests_proxy>
 {
 public:
     PerftestProxy(std::string destination, std::string objectPath)
@@ -54,7 +54,7 @@ public:
     }
 
 protected:
-    virtual void onDataSignal(const std::string& data) override
+    virtual void onDataSignal([[maybe_unused]] const std::string& data) override
     {
         static unsigned int counter = 0;
         static std::chrono::time_point<std::chrono::steady_clock> startTime;

tests/perftests/perftests-adaptor.h

@@ -22,9 +22,9 @@ protected:
     perftests_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("sendDataSignals").onInterface(INTERFACE_NAME).implementedAs([this](const uint32_t& numberOfSignals, const uint32_t& signalMsgSize){ return this->sendDataSignals(numberOfSignals, signalMsgSize); });
-        object_.registerMethod("concatenateTwoStrings").onInterface(INTERFACE_NAME).implementedAs([this](const std::string& string1, const std::string& string2){ return this->concatenateTwoStrings(string1, string2); });
-        object_.registerSignal("dataSignal").onInterface(INTERFACE_NAME).withParameters<std::string>();
+        object_.registerMethod("sendDataSignals").onInterface(INTERFACE_NAME).withInputParamNames("numberOfSignals", "signalMsgSize").implementedAs([this](const uint32_t& numberOfSignals, const uint32_t& signalMsgSize){ return this->sendDataSignals(numberOfSignals, signalMsgSize); });
+        object_.registerMethod("concatenateTwoStrings").onInterface(INTERFACE_NAME).withInputParamNames("string1", "string2").withOutputParamNames("result").implementedAs([this](const std::string& string1, const std::string& string2){ return this->concatenateTwoStrings(string1, string2); });
+        object_.registerSignal("dataSignal").onInterface(INTERFACE_NAME).withParameters<std::string>("data");
     }
 
     ~perftests_adaptor() = default;

tests/perftests/server.cpp

@@ -36,7 +36,7 @@ using namespace std::chrono_literals;
 
 std::string createRandomString(size_t length);
 
-class PerftestAdaptor : public sdbus::AdaptorInterfaces<org::sdbuscpp::perftests_adaptor>
+class PerftestAdaptor final : public sdbus::AdaptorInterfaces<org::sdbuscpp::perftests_adaptor>
 {
 public:
     PerftestAdaptor(sdbus::IConnection& connection, std::string objectPath)
@@ -97,5 +97,5 @@ int main(int /*argc*/, char */*argv*/[])
     const char* objectPath = "/org/sdbuscpp/perftests";
     PerftestAdaptor server(*connection, objectPath);
 
-    connection->enterProcessingLoop();
+    connection->enterEventLoop();
 }

tests/stresstests/celsius-thermometer-adaptor.h

@@ -24,7 +24,7 @@ protected:
     thermometer_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getCurrentTemperature(); });
+        object_.registerMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).withOutputParamNames("result").implementedAs([this](){ return this->getCurrentTemperature(); });
     }
 
     ~thermometer_adaptor() = default;

tests/stresstests/concatenator-adaptor.h

@@ -23,8 +23,8 @@ protected:
     concatenator_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("concatenate").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params){ this->concatenate(std::move(result), std::move(params)); });
-        object_.registerSignal("concatenatedSignal").onInterface(INTERFACE_NAME).withParameters<std::string>();
+        object_.registerMethod("concatenate").onInterface(INTERFACE_NAME).withInputParamNames("params").withOutputParamNames("result").implementedAs([this](sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params){ this->concatenate(std::move(result), std::move(params)); });
+        object_.registerSignal("concatenatedSignal").onInterface(INTERFACE_NAME).withParameters<std::string>("concatenatedString");
     }
 
     ~concatenator_adaptor() = default;

tests/stresstests/concatenator-proxy.h

@@ -33,9 +33,9 @@ protected:
     virtual void onConcatenateReply(const std::string& result, const sdbus::Error* error) = 0;
 
 public:
-    void concatenate(const std::map<std::string, sdbus::Variant>& params)
+    sdbus::PendingAsyncCall concatenate(const std::map<std::string, sdbus::Variant>& params)
     {
-        proxy_.callMethodAsync("concatenate").onInterface(INTERFACE_NAME).withArguments(params).uponReplyInvoke([this](const sdbus::Error* error, const std::string& result){ this->onConcatenateReply(result, error); });
+        return proxy_.callMethodAsync("concatenate").onInterface(INTERFACE_NAME).withArguments(params).uponReplyInvoke([this](const sdbus::Error* error, const std::string& result){ this->onConcatenateReply(result, error); });
     }
 
 private:

tests/stresstests/fahrenheit-thermometer-adaptor.h

@@ -24,7 +24,7 @@ protected:
     thermometer_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getCurrentTemperature(); });
+        object_.registerMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).withOutputParamNames("result").implementedAs([this](){ return this->getCurrentTemperature(); });
     }
 
     ~thermometer_adaptor() = default;
@@ -53,8 +53,8 @@ protected:
     factory_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("createDelegateObject").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<sdbus::ObjectPath>&& result){ this->createDelegateObject(std::move(result)); });
-        object_.registerMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Result<>&& result, sdbus::ObjectPath delegate){ this->destroyDelegateObject(std::move(result), std::move(delegate)); }).withNoReply();
+        object_.registerMethod("createDelegateObject").onInterface(INTERFACE_NAME).withOutputParamNames("delegate").implementedAs([this](sdbus::Result<sdbus::ObjectPath>&& result){ this->createDelegateObject(std::move(result)); });
+        object_.registerMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).withInputParamNames("delegate").implementedAs([this](sdbus::Result<>&& result, sdbus::ObjectPath delegate){ this->destroyDelegateObject(std::move(result), std::move(delegate)); }).withNoReply();
     }
 
     ~factory_adaptor() = default;

tests/stresstests/sdbus-c++-stress-tests.cpp

@@ -53,7 +53,7 @@ using namespace std::string_literals;
 #define FAHRENHEIT_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstests/fahrenheit/thermometer"s
 #define CONCATENATOR_OBJECT_PATH "/org/sdbuscpp/stresstests/concatenator"s
 
-class CelsiusThermometerAdaptor : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::celsius::thermometer_adaptor>
+class CelsiusThermometerAdaptor final : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::celsius::thermometer_adaptor>
 {
 public:
     CelsiusThermometerAdaptor(sdbus::IConnection& connection, std::string objectPath)
@@ -92,8 +92,8 @@ public:
     }
 };
 
-class FahrenheitThermometerAdaptor : public sdbus::AdaptorInterfaces< org::sdbuscpp::stresstests::fahrenheit::thermometer_adaptor
-                                                                    , org::sdbuscpp::stresstests::fahrenheit::thermometer::factory_adaptor >
+class FahrenheitThermometerAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::stresstests::fahrenheit::thermometer_adaptor
+                                                                          , org::sdbuscpp::stresstests::fahrenheit::thermometer::factory_adaptor >
 {
 public:
     FahrenheitThermometerAdaptor(sdbus::IConnection& connection, std::string objectPath, bool isDelegate)
@@ -222,7 +222,7 @@ public:
     }
 };
 
-class ConcatenatorAdaptor : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::concatenator_adaptor>
+class ConcatenatorAdaptor final : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::concatenator_adaptor>
 {
 public:
     ConcatenatorAdaptor(sdbus::IConnection& connection, std::string objectPath)
@@ -294,7 +294,7 @@ private:
     std::atomic<bool> exit_{};
 };
 
-class ConcatenatorProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstests::concatenator_proxy>
+class ConcatenatorProxy final : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstests::concatenator_proxy>
 {
 public:
     ConcatenatorProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
@@ -309,7 +309,7 @@ public:
     }
 
 private:
-    virtual void onConcatenateReply(const std::string& result, const sdbus::Error* error) override
+    virtual void onConcatenateReply(const std::string& result, [[maybe_unused]] const sdbus::Error* error) override
     {
         assert(error == nullptr);
 
@@ -392,7 +392,7 @@ int main(int argc, char *argv[])
         {
             CelsiusThermometerAdaptor thermometer(con, CELSIUS_THERMOMETER_OBJECT_PATH);
             service2ThreadReady = true;
-            con.enterProcessingLoop();
+            con.enterEventLoop();
         });
 
         auto service1Connection = sdbus::createSystemBusConnection(SERVICE_1_BUS_NAME);
@@ -402,7 +402,7 @@ int main(int argc, char *argv[])
             ConcatenatorAdaptor concatenator(con, CONCATENATOR_OBJECT_PATH);
             FahrenheitThermometerAdaptor thermometer(con, FAHRENHEIT_THERMOMETER_OBJECT_PATH, false);
             service1ThreadReady = true;
-            con.enterProcessingLoop();
+            con.enterEventLoop();
         });
 
         // Wait for both services to export their D-Bus objects
@@ -457,7 +457,7 @@ int main(int argc, char *argv[])
 
                 FahrenheitThermometerProxy thermometer(con, SERVICE_1_BUS_NAME, FAHRENHEIT_THERMOMETER_OBJECT_PATH);
                 uint32_t localCounter{};
-                uint32_t previousTemperature{};
+                [[maybe_unused]] uint32_t previousTemperature{};
 
                 while (!stopClients)
                 {
@@ -480,8 +480,8 @@ int main(int argc, char *argv[])
 
             // We could run the loop in a sync way, but we want it to run also when proxies are destroyed for better
             // coverage of multi-threaded scenarios, so we run it async and use condition variable for exit notification
-            //con.enterProcessingLoop();
-            con.enterProcessingLoopAsync();
+            //con.enterEventLoop();
+            con.enterEventLoopAsync();
 
             std::unique_lock<std::mutex> lock(clientThreadExitMutex);
             clientThreadExitCond.wait(lock, [&]{return clientThreadExit;});
@@ -493,17 +493,17 @@ int main(int argc, char *argv[])
 
         std::this_thread::sleep_for(std::chrono::milliseconds(loopDuration));
 
-        //clientConnection->leaveProcessingLoop();
+        //clientConnection->leaveEventLoop();
         std::unique_lock<std::mutex> lock(clientThreadExitMutex);
         clientThreadExit = true;
         lock.unlock();
         clientThreadExitCond.notify_one();
         clientThread.join();
 
-        service1Connection->leaveProcessingLoop();
+        service1Connection->leaveEventLoop();
         service1Thread.join();
 
-        service2Connection->leaveProcessingLoop();
+        service2Connection->leaveEventLoop();
         service2Thread.join();
     }
 

tests/unittests/Connection_test.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Connection_test.cpp
  * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@@ -35,10 +35,7 @@ using ::testing::DoAll;
 using ::testing::SetArgPointee;
 using ::testing::Return;
 using ::testing::NiceMock;
-using sdbus::internal::Connection;
-constexpr sdbus::internal::Connection::system_bus_t system_bus;
-constexpr sdbus::internal::Connection::session_bus_t session_bus;
-constexpr sdbus::internal::Connection::remote_system_bus_t remote_system_bus;
+using ::sdbus::internal::Connection;
 
 class ConnectionCreationTest : public ::testing::Test
 {
@@ -49,61 +46,89 @@ protected:
     sd_bus* fakeBusPtr_ = reinterpret_cast<sd_bus*>(1);
 };
 
+using ADefaultBusConnection = ConnectionCreationTest;
 using ASystemBusConnection = ConnectionCreationTest;
 using ASessionBusConnection = ConnectionCreationTest;
 
+TEST_F(ADefaultBusConnection, OpensAndFlushesBusWhenCreated)
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush(_)).Times(1);
+    Connection(std::move(sdBusIntfMock_), Connection::default_bus);
+}
+
 TEST_F(ASystemBusConnection, OpensAndFlushesBusWhenCreated)
 {
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), system_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::system_bus);
 }
 
 TEST_F(ASessionBusConnection, OpensAndFlushesBusWhenCreated)
 {
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), session_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::session_bus);
+}
+
+TEST_F(ADefaultBusConnection, ClosesAndUnrefsBusWhenDestructed)
+{
+    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).Times(1);
+    Connection(std::move(sdBusIntfMock_), Connection::default_bus);
 }
 
 TEST_F(ASystemBusConnection, ClosesAndUnrefsBusWhenDestructed)
 {
-    ON_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), session_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::system_bus);
 }
 
 TEST_F(ASessionBusConnection, ClosesAndUnrefsBusWhenDestructed)
 {
     ON_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).Times(1);
-    Connection(std::move(sdBusIntfMock_), session_bus);
+    Connection(std::move(sdBusIntfMock_), Connection::session_bus);
+}
+
+TEST_F(ADefaultBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
+{
+    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(-1)));
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::default_bus), sdbus::Error);
 }
 
 TEST_F(ASystemBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
 {
     ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(-1)));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), system_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::system_bus), sdbus::Error);
 }
 
 TEST_F(ASessionBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
 {
     ON_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(-1)));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), session_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::session_bus), sdbus::Error);
+}
+
+TEST_F(ADefaultBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
+{
+    ON_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    ON_CALL(*sdBusIntfMock_, sd_bus_flush(_)).WillByDefault(Return(-1));
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::default_bus), sdbus::Error);
 }
 
 TEST_F(ASystemBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
 {
     ON_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
     ON_CALL(*sdBusIntfMock_, sd_bus_flush(_)).WillByDefault(Return(-1));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), system_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::system_bus), sdbus::Error);
 }
 
 TEST_F(ASessionBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
 {
     ON_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
     ON_CALL(*sdBusIntfMock_, sd_bus_flush(_)).WillByDefault(Return(-1));
-    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), session_bus), sdbus::Error);
+    ASSERT_THROW(Connection(std::move(sdBusIntfMock_), Connection::session_bus), sdbus::Error);
 }
 
 namespace
@@ -128,6 +153,10 @@ protected:
     std::unique_ptr<Connection> con_;
 };
 
+template<> void AConnectionNameRequest<Connection::default_bus_t>::setUpBusOpenExpectation()
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+}
 template<> void AConnectionNameRequest<Connection::system_bus_t>::setUpBusOpenExpectation()
 {
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
@@ -136,23 +165,40 @@ template<> void AConnectionNameRequest<Connection::session_bus_t>::setUpBusOpenE
 {
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
 }
+template<> void AConnectionNameRequest<Connection::custom_session_bus_t>::setUpBusOpenExpectation()
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_user_with_address(_, _)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+}
 template<> void AConnectionNameRequest<Connection::remote_system_bus_t>::setUpBusOpenExpectation()
 {
     EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_system_remote(_, _)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
 }
+template<> void AConnectionNameRequest<Connection::pseudo_bus_t>::setUpBusOpenExpectation()
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_new(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+    // `sd_bus_start` for pseudo connection shall return an error value, remember this is a fake connection...
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_start(fakeBusPtr_)).WillOnce(Return(-EINVAL));
+}
 template <typename _BusTypeTag>
 std::unique_ptr<Connection> AConnectionNameRequest<_BusTypeTag>::makeConnection()
 {
     return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), _BusTypeTag{});
 }
+template<> std::unique_ptr<Connection> AConnectionNameRequest<Connection::custom_session_bus_t>::makeConnection()
+{
+    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), Connection::custom_session_bus, "custom session bus");
+}
 template<> std::unique_ptr<Connection> AConnectionNameRequest<Connection::remote_system_bus_t>::makeConnection()
 {
-    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), remote_system_bus, "some host");
+    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), Connection::remote_system_bus, "some host");
 }
 
-typedef ::testing::Types< Connection::system_bus_t
+typedef ::testing::Types< Connection::default_bus_t
+                        , Connection::system_bus_t
                         , Connection::session_bus_t
+                        , Connection::custom_session_bus_t
                         , Connection::remote_system_bus_t
+                        , Connection::pseudo_bus_t
                         > BusTypeTags;
 
 TYPED_TEST_SUITE(AConnectionNameRequest, BusTypeTags);

tests/unittests/Message_test.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Message_test.cpp
  *
@@ -238,3 +238,29 @@ TEST(AMessage, CanCarryAComplexType)
 
     ASSERT_THAT(dataRead, Eq(dataWritten));
 }
+
+TEST(AMessage, CanPeekASimpleType)
+{
+    auto msg = sdbus::createPlainMessage();
+    msg << 123;
+    msg.seal();
+
+    std::string type;
+    std::string contents;
+    msg.peekType(type, contents);
+    ASSERT_THAT(type, "i");
+    ASSERT_THAT(contents, "");
+}
+
+TEST(AMessage, CanPeekContainerContents)
+{
+    auto msg = sdbus::createPlainMessage();
+    msg << std::map<int, std::string>{{1, "one"}, {2, "two"}};
+    msg.seal();
+
+    std::string type;
+    std::string contents;
+    msg.peekType(type, contents);
+    ASSERT_THAT(type, "a");
+    ASSERT_THAT(contents, "{is}");
+}

tests/unittests/TypeTraits_test.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file TypeTraits_test.cpp
  *

tests/unittests/Types_test.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file Types_test.cpp
  *
@@ -69,7 +69,7 @@ TEST(AVariant, CanBeConstructedFromAComplexValue)
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
     ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
 
-    ASSERT_NO_THROW(sdbus::Variant(value));
+    ASSERT_NO_THROW(sdbus::Variant{value});
 }
 
 TEST(AVariant, CanBeCopied)
@@ -230,6 +230,15 @@ TEST(AnObjectPath, CanBeConstructedFromStdString)
     ASSERT_THAT(sdbus::ObjectPath{aPath}, Eq(aPath));
 }
 
+TEST(AnObjectPath, CanBeMovedLikeAStdString)
+{
+    std::string aPath{"/some/very/long/path/longer/than/sso"};
+    sdbus::ObjectPath oPath{aPath};
+
+    ASSERT_THAT(sdbus::ObjectPath{std::move(oPath)}, Eq(sdbus::ObjectPath(std::move(aPath))));
+    ASSERT_THAT(std::string(oPath), Eq(aPath));
+}
+
 TEST(ASignature, CanBeConstructedFromCString)
 {
     const char* aSignature = "us";
@@ -244,6 +253,15 @@ TEST(ASignature, CanBeConstructedFromStdString)
     ASSERT_THAT(sdbus::Signature{aSignature}, Eq(aSignature));
 }
 
+TEST(ASignature, CanBeMovedLikeAStdString)
+{
+    std::string aSignature{"us"};
+    sdbus::Signature oSignature{aSignature};
+
+    ASSERT_THAT(sdbus::Signature{std::move(oSignature)}, Eq(sdbus::Signature(std::move(aSignature))));
+    ASSERT_THAT(std::string(oSignature), Eq(aSignature));
+}
+
 TEST(AUnixFd, DuplicatesAndOwnsFdUponStandardConstruction)
 {
     auto fd = ::eventfd(0, EFD_SEMAPHORE | EFD_NONBLOCK);
@@ -344,3 +362,21 @@ TEST(AUnixFd, TakesOverNewFdAndClosesOriginalFdOnAdoptingReset)
     EXPECT_THAT(unixFd.get(), Eq(newFd));
     EXPECT_THAT(::close(fd), Eq(-1));
 }
+
+TEST(AnError, CanBeConstructedFromANameAndAMessage)
+{
+    auto error = sdbus::Error("name", "message");
+    EXPECT_THAT(error.getName(), Eq<std::string>("name"));
+    EXPECT_THAT(error.getMessage(), Eq<std::string>("message"));
+}
+
+TEST(AnError, CanBeConstructedFromANameOnly)
+{
+    auto error1 = sdbus::Error("name");
+    auto error2 = sdbus::Error("name", nullptr);
+    EXPECT_THAT(error1.getName(), Eq<std::string>("name"));
+    EXPECT_THAT(error2.getName(), Eq<std::string>("name"));
+
+    EXPECT_THAT(error1.getMessage(), Eq<std::string>(""));
+    EXPECT_THAT(error2.getMessage(), Eq<std::string>(""));
+}

tests/unittests/mocks/SdBusMock.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file SdBusMock.h
  * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@@ -42,6 +42,7 @@ public:
     MOCK_METHOD5(sd_bus_call, int(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *ret_error, sd_bus_message **reply));
     MOCK_METHOD6(sd_bus_call_async, int(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m, sd_bus_message_handler_t callback, void *userdata, uint64_t usec));
 
+    MOCK_METHOD3(sd_bus_message_new, int(sd_bus *bus, sd_bus_message **m, uint8_t type));
     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_METHOD5(sd_bus_message_new_signal, int(sd_bus *bus, sd_bus_message **m, const char *path, const char *interface, const char *member));
     MOCK_METHOD2(sd_bus_message_new_method_return, int(sd_bus_message *call, sd_bus_message **m));
@@ -56,8 +57,10 @@ public:
     MOCK_METHOD3(sd_bus_emit_interfaces_added_strv, int(sd_bus *bus, const char *path, char **interfaces));
     MOCK_METHOD3(sd_bus_emit_interfaces_removed_strv, int(sd_bus *bus, const char *path, char **interfaces));
 
-    MOCK_METHOD1(sd_bus_open_user, int(sd_bus **ret));
+    MOCK_METHOD1(sd_bus_open, int(sd_bus **ret));
     MOCK_METHOD1(sd_bus_open_system, int(sd_bus **ret));
+    MOCK_METHOD1(sd_bus_open_user, int(sd_bus **ret));
+    MOCK_METHOD2(sd_bus_open_user_with_address, int(sd_bus **ret, const char* address));
     MOCK_METHOD2(sd_bus_open_system_remote, int(sd_bus **ret, const char *host));
     MOCK_METHOD3(sd_bus_request_name, int(sd_bus *bus, const char *name, uint64_t flags));
     MOCK_METHOD2(sd_bus_release_name, int(sd_bus *bus, const char *name));
@@ -67,11 +70,28 @@ public:
     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_slot_unref, sd_bus_slot*(sd_bus_slot *slot));
 
+    MOCK_METHOD1(sd_bus_new, int(sd_bus **ret));
+    MOCK_METHOD1(sd_bus_start, int(sd_bus *bus));
+
     MOCK_METHOD2(sd_bus_process, int(sd_bus *bus, sd_bus_message **r));
     MOCK_METHOD2(sd_bus_get_poll_data, int(sd_bus *bus, PollData* data));
 
     MOCK_METHOD1(sd_bus_flush, int(sd_bus *bus));
     MOCK_METHOD1(sd_bus_flush_close_unref, sd_bus *(sd_bus *bus));
+    MOCK_METHOD1(sd_bus_close_unref, sd_bus *(sd_bus *bus));
+
+    MOCK_METHOD2(sd_bus_message_set_destination, int(sd_bus_message *m, const char *destination));
+
+    MOCK_METHOD3(sd_bus_query_sender_creds, int(sd_bus_message *, uint64_t, sd_bus_creds **));
+    MOCK_METHOD1(sd_bus_creds_unref, sd_bus_creds*(sd_bus_creds *));
+
+    MOCK_METHOD2(sd_bus_creds_get_pid, int(sd_bus_creds *, pid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_uid, int(sd_bus_creds *, uid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_euid, int(sd_bus_creds *, uid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_gid, int(sd_bus_creds *, gid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_egid, int(sd_bus_creds *, gid_t *));
+    MOCK_METHOD2(sd_bus_creds_get_supplementary_gids, int(sd_bus_creds *, const gid_t **));
+    MOCK_METHOD2(sd_bus_creds_get_selinux_context, int(sd_bus_creds *, const char **));
 };
 
 #endif //SDBUS_CXX_SDBUS_MOCK_H

tests/unittests/sdbus-c++-unit-tests.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file sdbus-c++-unit-tests.cpp
  *

tools/CMakeLists.txt

@@ -4,7 +4,7 @@
 
 cmake_minimum_required(VERSION 3.5)
 
-project(sdbus-c++-tools)
+project(sdbus-c++-tools VERSION 1.2.0)
 
 include(GNUInstallDirs)
 
@@ -43,9 +43,33 @@ set(CMAKE_CXX_STANDARD 14)
 
 add_executable(sdbus-c++-xml2cpp ${SDBUSCPP_XML2CPP_SRCS})
 target_link_libraries (sdbus-c++-xml2cpp ${EXPAT_LIBRARIES})
+target_include_directories(sdbus-c++-xml2cpp PRIVATE ${EXPAT_INCLUDE_DIRS})
 
 #----------------------------------
 # INSTALLATION
 #----------------------------------
 
-install(TARGETS sdbus-c++-xml2cpp EXPORT sdbus-c++-xml2cpp DESTINATION ${CMAKE_INSTALL_BINDIR})
+install(TARGETS sdbus-c++-xml2cpp EXPORT sdbus-c++-tools-targets DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT dev)
+
+#----------------------------------
+# CMAKE CONFIG & PACKAGE CONFIG
+#----------------------------------
+
+include(CMakePackageConfigHelpers)
+
+install(EXPORT sdbus-c++-tools-targets
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++-tools
+        NAMESPACE SDBusCpp::
+        COMPONENT dev)
+
+configure_package_config_file(cmake/sdbus-c++-tools-config.cmake.in cmake/sdbus-c++-tools-config.cmake
+                              INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++)
+write_basic_package_version_file(cmake/sdbus-c++-tools-config-version.cmake COMPATIBILITY SameMajorVersion)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-tools-config.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-tools-config-version.cmake
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++-tools
+        COMPONENT dev)
+
+configure_file(pkgconfig/sdbus-c++-tools.pc.in pkgconfig/sdbus-c++-tools.pc @ONLY)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/sdbus-c++-tools.pc
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT dev)

tools/cmake/sdbus-c++-tools-config.cmake.in

@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@-targets.cmake")
+check_required_components("sdbus-c++-xml2cpp")

tools/pkgconfig/sdbus-c++-tools.pc.in

@@ -0,0 +1,8 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
+
+Name: @PROJECT_NAME@
+Description: Stub generator tool for sdbus-c++ library
+Version: @SDBUSCPP_VERSION@

tools/xml2cpp-codegen/AdaptorGenerator.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file AdaptorGenerator.cpp
  *
@@ -164,6 +164,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
     for (const auto& method : methods)
     {
         auto methodName = method->get("name");
+        auto methodNameSafe = mangle_name(methodName);
 
         auto annotations = getAnnotations(*method);
         bool async{false};
@@ -204,19 +205,22 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
         Nodes inArgs = args.select("direction" , "in");
         Nodes outArgs = args.select("direction" , "out");
 
-        std::string argStr, argTypeStr;
-        std::tie(argStr, argTypeStr, std::ignore) = argsToNamesAndTypes(inArgs, async);
+        std::string argStr, argTypeStr, argStringsStr, outArgStringsStr;
+        std::tie(argStr, argTypeStr, std::ignore, argStringsStr) = argsToNamesAndTypes(inArgs, async);
+        std::tie(std::ignore, std::ignore, std::ignore, outArgStringsStr) = argsToNamesAndTypes(outArgs);
 
         using namespace std::string_literals;
 
         registrationSS << tab << tab << "object_.registerMethod(\""
                 << methodName << "\")"
                 << ".onInterface(INTERFACE_NAME)"
+                << (!argStringsStr.empty() ? (".withInputParamNames(" + argStringsStr + ")") : "")
+                << (!outArgStringsStr.empty() ? (".withOutputParamNames(" + outArgStringsStr + ")") : "")
                 << ".implementedAs("
                 << "[this]("
                 << (async ? "sdbus::Result<" + outArgsToType(outArgs, true) + ">&& result" + (argTypeStr.empty() ? "" : ", ") : "")
                 << argTypeStr
-                << "){ " << (async ? "" : "return ") << "this->" << methodName << "("
+                << "){ " << (async ? "" : "return ") << "this->" << methodNameSafe << "("
                 << (async ? "std::move(result)"s + (argTypeStr.empty() ? "" : ", ") : "")
                 << argStr << "); })"
                 << annotationRegistration << ";" << endl;
@@ -224,7 +228,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
         declarationSS << tab
                 << "virtual "
                 << (async ? "void" : outArgsToType(outArgs))
-                << " " << methodName
+                << " " << methodNameSafe
                 << "("
                 << (async ? "sdbus::Result<" + outArgsToType(outArgs, true) + ">&& result" + (argTypeStr.empty() ? "" : ", ") : "")
                 << argTypeStr
@@ -259,8 +263,8 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
 
         Nodes args = (*signal)["arg"];
 
-        std::string argStr, argTypeStr, typeStr;;
-        std::tie(argStr, argTypeStr, typeStr) = argsToNamesAndTypes(args);
+        std::string argStr, argTypeStr, typeStr, argStringsStr;
+        std::tie(argStr, argTypeStr, typeStr, argStringsStr) = argsToNamesAndTypes(args);
 
         signalRegistrationSS << tab << tab
                 << "object_.registerSignal(\"" << name << "\")"
@@ -268,7 +272,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
 
         if (args.size() > 0)
         {
-            signalRegistrationSS << ".withParameters<" << typeStr << ">()";
+            signalRegistrationSS << ".withParameters<" << typeStr << ">(" << argStringsStr << ")";
         }
 
         signalRegistrationSS << annotationRegistration;
@@ -276,6 +280,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
 
         auto nameWithCapFirstLetter = name;
         nameWithCapFirstLetter[0] = std::toupper(nameWithCapFirstLetter[0]);
+        nameWithCapFirstLetter = mangle_name(nameWithCapFirstLetter);
 
         signalMethodSS << tab << "void emit" << nameWithCapFirstLetter << "(" << argTypeStr << ")" << endl
                 << tab << "{" << endl
@@ -302,6 +307,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const N
     for (const auto& property : properties)
     {
         auto propertyName = property->get("name");
+        auto propertyNameSafe = mangle_name(propertyName);
         auto propertyAccess = property->get("access");
         auto propertySignature = property->get("type");
 
@@ -333,23 +339,23 @@ std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const N
 
         if (propertyAccess == "read" || propertyAccess == "readwrite")
         {
-            registrationSS << ".withGetter([this](){ return this->" << propertyName << "(); })";
+            registrationSS << ".withGetter([this](){ return this->" << propertyNameSafe << "(); })";
         }
 
         if (propertyAccess == "readwrite" || propertyAccess == "write")
         {
             registrationSS
                 << ".withSetter([this](" << propertyTypeArg << ")"
-                   "{ this->" << propertyName << "(" << propertyArg << "); })";
+                   "{ this->" << propertyNameSafe << "(" << propertyArg << "); })";
         }
 
         registrationSS << annotationRegistration;
         registrationSS << ";" << endl;
 
         if (propertyAccess == "read" || propertyAccess == "readwrite")
-            declarationSS << tab << "virtual " << propertyType << " " << propertyName << "() = 0;" << endl;
+            declarationSS << tab << "virtual " << propertyType << " " << propertyNameSafe << "() = 0;" << endl;
         if (propertyAccess == "readwrite" || propertyAccess == "write")
-            declarationSS << tab << "virtual void " << propertyName << "(" << propertyTypeArg << ") = 0;" << endl;
+            declarationSS << tab << "virtual void " << propertyNameSafe << "(" << propertyTypeArg << ") = 0;" << endl;
     }
 
     return std::make_tuple(registrationSS.str(), declarationSS.str());

tools/xml2cpp-codegen/AdaptorGenerator.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file AdaptorGenerator.h
  *

tools/xml2cpp-codegen/BaseGenerator.cpp

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file BaseGenerator.cpp
  *
@@ -96,6 +96,7 @@ std::tuple<unsigned, std::string> BaseGenerator::generateNamespaces(const std::s
     {
         std::string nspace;
         getline(ss, nspace, '.');
+        nspace = mangle_name(nspace);
         body << "namespace " << nspace << " {" << endl;
         ++count;
     }
@@ -105,9 +106,9 @@ std::tuple<unsigned, std::string> BaseGenerator::generateNamespaces(const std::s
 }
 
 
-std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndTypes(const Nodes& args, bool async) const
+std::tuple<std::string, std::string, std::string, std::string> BaseGenerator::argsToNamesAndTypes(const Nodes& args, bool async) const
 {
-    std::ostringstream argSS, argTypeSS, typeSS;
+    std::ostringstream argSS, argTypeSS, typeSS, argStringsSS;
 
     for (size_t i = 0; i < args.size(); ++i)
     {
@@ -115,6 +116,7 @@ std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndT
         if (i > 0)
         {
             argSS << ", ";
+            argStringsSS << ", ";
             argTypeSS << ", ";
             typeSS << ", ";
         }
@@ -124,21 +126,23 @@ std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndT
         {
             argName = "arg" + std::to_string(i);
         }
+        auto argNameSafe = mangle_name(argName);
         auto type = signature_to_type(arg->get("type"));
+        argStringsSS << "\"" << argName << "\"";
         if (!async)
         {
-            argSS << argName;
-            argTypeSS << "const " << type << "& " << argName;
+            argSS << argNameSafe;
+            argTypeSS << "const " << type << "& " << argNameSafe;
         }
         else
         {
-            argSS << "std::move(" << argName << ")";
-            argTypeSS << type << " " << argName;
+            argSS << "std::move(" << argNameSafe << ")";
+            argTypeSS << type << " " << argNameSafe;
         }
         typeSS << type;
     }
 
-    return std::make_tuple(argSS.str(), argTypeSS.str(), typeSS.str());
+    return std::make_tuple(argSS.str(), argTypeSS.str(), typeSS.str(), argStringsSS.str());
 }
 
 /**
@@ -178,4 +182,3 @@ std::string BaseGenerator::outArgsToType(const Nodes& args, bool bareList) const
 
     return retTypeSS.str();
 }
-

tools/xml2cpp-codegen/BaseGenerator.h

@@ -1,6 +1,6 @@
 /**
- * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
  * @file BaseGenerator.h
  *
@@ -88,7 +88,7 @@ protected:
      * @param args
      * @return tuple: argument names, argument types and names, argument types
      */
-    std::tuple<std::string, std::string, std::string> argsToNamesAndTypes(const sdbuscpp::xml::Nodes& args, bool async = false) const;
+    std::tuple<std::string, std::string, std::string, std::string> argsToNamesAndTypes(const sdbuscpp::xml::Nodes& args, bool async = false) const;
 
     /**
      * Output arguments to return type