Bump revision up to v0.8.2

This should not be required in C++17 because there is an appropriate
class template deduction rule [1] which infers that it's going to be a
weak_ptr<T> when constructing from a shared_ptr<T>. However, in
clang/LLVM's libcxx C++ STL implementation this only got implemented in
May 2020 [2].

[1] https://en.cppreference.com/w/cpp/memory/weak_ptr/deduction_guides
[2] https://reviews.llvm.org/D69603

.gitignore

@@ -7,9 +7,9 @@ build/
 .deps/
 .dirstamp
 .libs/
-test/libsdbus-c++_unittests
-test/libsdbus-c++_integrationtests
-test/run-test-on-device.sh
+tests/libsdbus-c++_unittests
+tests/libsdbus-c++_integrationtests
+tests/run-test-on-device.sh
 
 #eclipse
 .cproject

AUTHORS

@@ -1,5 +1,7 @@
-The library:
-  Stanislav Angelovic (stanislav.angelovic[at]kistler.com)
+sdbus-c++ library:
+  Stanislav Angelovic (https://github.com/sangelovic)
 
-Stub generator:
-  Lukas Durfina (lukas.durfina[at]kistler.com)
+Code generator:
+  Lukas Durfina (https://github.com/lukasdurfina)
+
+... and other contributors :)

CMakeLists.txt

@@ -2,34 +2,47 @@
 # PROJECT INFORMATION
 #-------------------------------
 
-cmake_minimum_required(VERSION 3.8)
+cmake_minimum_required(VERSION 3.13)
 
-project(sdbus-c++ VERSION 0.5.0 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 0.8.2 LANGUAGES C CXX)
 
 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file
 
 #-------------------------------
-# PERFORMING CHECKS
+# PERFORMING CHECKS & PREPARING THE DEPENDENCIES
 #-------------------------------
 
-find_package(PkgConfig REQUIRED)
-pkg_check_modules(SYSTEMD REQUIRED libsystemd>=236)
+option(BUILD_LIBSYSTEMD "Build libsystemd static library and incorporate it into libsdbus-c++" OFF)
+
+if(NOT BUILD_LIBSYSTEMD)
+    find_package(PkgConfig REQUIRED)
+    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)")
+    endif()
+    add_library(Systemd::Libsystemd ALIAS PkgConfig::Systemd)
+    set(LIBSYSTEMD_VERSION ${Systemd_VERSION})
+else()
+    # Build static libsystemd library as an external project
+    include(cmake/LibsystemdExternalProject.cmake)
+endif()
 
 #-------------------------------
 # SOURCE FILES CONFIGURATION
 #-------------------------------
 
-set(SDBUSCPP_SOURCE_DIR ${CMAKE_SOURCE_DIR}/src)
+set(SDBUSCPP_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/src)
 set(SDBUSCPP_INCLUDE_SUBDIR sdbus-c++)
-set(SDBUSCPP_INCLUDE_DIR ${CMAKE_SOURCE_DIR}/include/${SDBUSCPP_INCLUDE_SUBDIR})
+set(SDBUSCPP_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include/${SDBUSCPP_INCLUDE_SUBDIR})
 
 set(SDBUSCPP_CPP_SRCS
     ${SDBUSCPP_SOURCE_DIR}/Connection.cpp
-    ${SDBUSCPP_SOURCE_DIR}/ConvenienceClasses.cpp
     ${SDBUSCPP_SOURCE_DIR}/Error.cpp
     ${SDBUSCPP_SOURCE_DIR}/Message.cpp
     ${SDBUSCPP_SOURCE_DIR}/Object.cpp
-    ${SDBUSCPP_SOURCE_DIR}/ObjectProxy.cpp
+    ${SDBUSCPP_SOURCE_DIR}/Proxy.cpp
     ${SDBUSCPP_SOURCE_DIR}/Types.cpp
     ${SDBUSCPP_SOURCE_DIR}/Flags.cpp
     ${SDBUSCPP_SOURCE_DIR}/VTableUtils.c
@@ -40,24 +53,24 @@ set(SDBUSCPP_HDR_SRCS
     ${SDBUSCPP_SOURCE_DIR}/IConnection.h
     ${SDBUSCPP_SOURCE_DIR}/MessageUtils.h
     ${SDBUSCPP_SOURCE_DIR}/Object.h
-    ${SDBUSCPP_SOURCE_DIR}/ObjectProxy.h
+    ${SDBUSCPP_SOURCE_DIR}/Proxy.h
     ${SDBUSCPP_SOURCE_DIR}/ScopeGuard.h
     ${SDBUSCPP_SOURCE_DIR}/VTableUtils.h
     ${SDBUSCPP_SOURCE_DIR}/SdBus.h
     ${SDBUSCPP_SOURCE_DIR}/ISdBus.h)
 
 set(SDBUSCPP_PUBLIC_HDRS
-    ${SDBUSCPP_INCLUDE_DIR}/ConvenienceClasses.h
-    ${SDBUSCPP_INCLUDE_DIR}/ConvenienceClasses.inl
+    ${SDBUSCPP_INCLUDE_DIR}/ConvenienceApiClasses.h
+    ${SDBUSCPP_INCLUDE_DIR}/ConvenienceApiClasses.inl
     ${SDBUSCPP_INCLUDE_DIR}/Error.h
     ${SDBUSCPP_INCLUDE_DIR}/IConnection.h
-    ${SDBUSCPP_INCLUDE_DIR}/Interfaces.h
-    ${SDBUSCPP_INCLUDE_DIR}/Introspection.h
+    ${SDBUSCPP_INCLUDE_DIR}/AdaptorInterfaces.h
+    ${SDBUSCPP_INCLUDE_DIR}/ProxyInterfaces.h
+    ${SDBUSCPP_INCLUDE_DIR}/StandardInterfaces.h
     ${SDBUSCPP_INCLUDE_DIR}/IObject.h
-    ${SDBUSCPP_INCLUDE_DIR}/IObjectProxy.h
+    ${SDBUSCPP_INCLUDE_DIR}/IProxy.h
     ${SDBUSCPP_INCLUDE_DIR}/Message.h
     ${SDBUSCPP_INCLUDE_DIR}/MethodResult.h
-    ${SDBUSCPP_INCLUDE_DIR}/MethodResult.inl
     ${SDBUSCPP_INCLUDE_DIR}/Types.h
     ${SDBUSCPP_INCLUDE_DIR}/TypeTraits.h
     ${SDBUSCPP_INCLUDE_DIR}/Flags.h
@@ -70,8 +83,6 @@ set(SDBUSCPP_SRCS ${SDBUSCPP_CPP_SRCS} ${SDBUSCPP_HDR_SRCS} ${SDBUSCPP_PUBLIC_HD
 #-------------------------------
 
 set(CMAKE_CXX_STANDARD 17)
-include_directories("${CMAKE_SOURCE_DIR}/include")
-include_directories("${CMAKE_SOURCE_DIR}/src")
 
 #----------------------------------
 # LIBRARY BUILD INFORMATION
@@ -80,28 +91,44 @@ include_directories("${CMAKE_SOURCE_DIR}/src")
 set(SDBUSCPP_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
 set(SDBUSCPP_VERSION "${PROJECT_VERSION}")
 
-# We are building in two steps: first objects, then link them into a library,
-# and that's because we need object files since unit tests link against them.
-add_library(sdbuscppobjects OBJECT ${SDBUSCPP_SRCS})
-target_include_directories(sdbuscppobjects PUBLIC ${SYSTEMD_INCLUDE_DIRS})
-target_compile_definitions(sdbuscppobjects PRIVATE BUILDLIB=1)
-set_target_properties(sdbuscppobjects PROPERTIES POSITION_INDEPENDENT_CODE 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()
 
-add_library(sdbus-c++ SHARED $<TARGET_OBJECTS:sdbuscppobjects>)
+# 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=${LIBSYSTEMD_VERSION})
+target_include_directories(sdbus-c++-objlib PUBLIC $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+                                                   $<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)
+
+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++
-    PROPERTIES
-    PUBLIC_HEADER "${SDBUSCPP_PUBLIC_HDRS}"
-    VERSION "${SDBUSCPP_VERSION}"
-    SOVERSION "${SDBUSCPP_VERSION_MAJOR}"
-    OUTPUT_NAME "sdbus-c++")
-
-target_link_libraries(sdbus-c++ ${SYSTEMD_LIBRARIES})
+                      PROPERTIES PUBLIC_HEADER "${SDBUSCPP_PUBLIC_HDRS}"
+                                 VERSION "${SDBUSCPP_VERSION}"
+                                 SOVERSION "${SDBUSCPP_VERSION_MAJOR}"
+                                 OUTPUT_NAME "sdbus-c++")
+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
@@ -111,11 +138,11 @@ install(TARGETS sdbus-c++
 # TESTS
 #----------------------------------
 
-option(ENABLE_TESTS "Build and install tests (default ON)" ON)
+option(BUILD_TESTS "Build and install tests (default OFF)" OFF)
 
-if(ENABLE_TESTS)
+if(BUILD_TESTS)
     enable_testing()
-    add_subdirectory("${CMAKE_SOURCE_DIR}/test")
+    add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/tests")
 endif()
 
 #----------------------------------
@@ -125,29 +152,40 @@ endif()
 option(BUILD_CODE_GEN "Build and install interface stub code generator (default OFF)" OFF)
 
 if(BUILD_CODE_GEN)
-    add_subdirectory("${CMAKE_SOURCE_DIR}/stub-generator")
+    add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/tools")
 endif()
 
 #----------------------------------
 # DOCUMENTATION
 #----------------------------------
 
-# TODO Build doxygen
+option(BUILD_DOC "Build documentation for sdbus-c++" ON)
+
+if(BUILD_DOC)
+    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})
+endif()
 
 #----------------------------------
 # CMAKE CONFIG & PACKAGE CONFIG
 #----------------------------------
 
 include(CMakePackageConfigHelpers)
-set(SDBUSCPP_CONFIG_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++)
 
-configure_file(sdbus-c++-config.cmake.in sdbus-c++-config.cmake @ONLY)
-install(FILES ${CMAKE_BINARY_DIR}/sdbus-c++-config.cmake DESTINATION ${SDBUSCPP_CONFIG_INSTALL_DIR} COMPONENT dev)
+install(EXPORT sdbus-c++-targets
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++
+        NAMESPACE SDBusCpp::
+        COMPONENT dev)
 
-write_basic_package_version_file(sdbus-c++-config-version.cmake
-        VERSION ${PROJECT_VERSION}
-        COMPATIBILITY AnyNewerVersion)
-install(FILES ${CMAKE_BINARY_DIR}/sdbus-c++-config-version.cmake DESTINATION ${SDBUSCPP_CONFIG_INSTALL_DIR} COMPONENT dev)
+configure_package_config_file(cmake/sdbus-c++-config.cmake.in cmake/sdbus-c++-config.cmake
+                              INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++)
+write_basic_package_version_file(cmake/sdbus-c++-config-version.cmake COMPATIBILITY SameMajorVersion)
+install(FILES ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-config.cmake
+              ${CMAKE_CURRENT_BINARY_DIR}/cmake/sdbus-c++-config-version.cmake
+        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++
+        COMPONENT dev)
 
-configure_file(sdbus-c++.pc.in sdbus-c++.pc @ONLY)
-install(FILES ${CMAKE_BINARY_DIR}/sdbus-c++.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT dev)
+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)

ChangeLog

@@ -54,7 +54,109 @@ v0.4.3
 
 v0.5.0
 - Redesign of the Connection model for scalability, thread-safety, simplicity and clarity
-- Introduce support asynchronous invocation of D-Bus methods on client-side
+- [[Breaking ABI change]] Introduce support for asynchronous invocation of D-Bus methods on client-side
 - Revise and extend sdbus-c++ tutorial
 - Introduce stress tests that involve a D-Bus server and client interacting in dense communication in both sync and async ways
 - Compilation error fixes for older gcc versions
+
+v0.5.1
+- Cleanups of CMakeLists.txt
+- Rename sdbus-c++ test executables for consistency
+- Rename sdbus-c++ stub code generator executable
+- Introduce generation of doxygen documentation
+- Improve documentation
+
+v0.5.2
+- Simplify and unify basic API level callbacks for both sync and async methods
+
+v0.5.3
+- Extend stress tests with dynamic object and proxy creation and destruction from multiple threads
+- [[Breaking ABI change]] Add getConnection() method to IObject
+- A few minor fixes
+
+v0.6.0
+- This release comes with a number of API and ABI breaking changes (that hopefully lead to a more mature and stable API for near future):
+  - Some constructs have been renamed (see below for details), you'll have to adapt your sources whether you're using the basic or the convenience sdbus-c++ API.
+  - You'll also have to re-generate adaptor/proxy stubs with the new stub code generator if you're using them.
+  - And you'll have to take care of manual registeration/deregistration in the constructors/destructors of your final adaptor and proxy classes. See updated using sdbus-c++ tutorial.
+- Cleaning up some names (of class, methods, files):
+  * ConvenienceClasses.h/.inl/.cpp -> ConvenienceApiClasses.h/.inl/.cpp
+  * IObjectProxy class -> IProxy
+  * Interfaces class -> AdaptorInterfaces
+  * Interfaces.h -> split into AdaptorInterfaces.h and ProxyInterfaces.h
+  * createObjectProxy() method -> createProxy()
+- Add new unregister() virtual function to IObject and IProxy to allow for safe construction and destructions of D-Bus ojects and proxies hooked to live D-Bus connections.
+- Extend stress tests to allow testing safe initialization/deinitialization of objects and proxies
+- Fix gcc warnings
+- Use release v1.8.1 of googletest for tests
+
+v0.7.0
+- [[Breaking ABI change]] Added full support for ObjectManager, Properties and other standard D-Bus interfaces (Reordering virtual functions in interface classes)
+- sdbus-c++ now can automatically download, build and incorporate libsystemd static library, which makes things pretty easy in non-systemd environments
+- Minor changes in generated proxy/adaptor code:
+  * renamed interfaceName to INTERFACE_NAME to avoid potential naming clashes
+  * signal emitting methods now begin with "emit" prefix and capitalized first letter of signal name
+- sdbus-c++ file organization has been adjusted to comply to de-facto OSS project standards
+- Build system improvements -- moving towards more modern CMake
+- Using googletest from master branch instead of v1.8.1 which has THREADS_PTHREAD_ARG issue when cross-compiling
+- Documentation improvements
+- Minor changes (renamings) in the code generated by sdbus-c++-xml2cpp generator
+- Other minor fixes and internal design improvements
+
+v0.7.1
+- Fixed waiting in integration tests
+- Added object manager automatically in ObjectManager_adaptor constructor
+- Introduced support for unix fd type
+- Redesigned Message class hierarchy to be more idiomatic, clean and intent-revealing
+- Resolved a few clang-tidy warnings and suggestions
+- Extended the tutorial with info on standard D-Bus interfaces
+- Added protected non-virtual destructor in generated *_proxy/*_adaptor classes
+
+v0.7.2
+- Rewrite UnixFd implementation from plain UnixFd struct to full-ownership-semantics UnixFd class
+
+v0.7.3
+- Add ability to integrate with external event loops
+- Add getSenderName() method to Message
+- Skip GetMachineId integration test case when /etc/machine-id is not available
+
+v0.7.4
+- Add support for custom timeout of D-Bus method calls
+- Add support for opening a connection to a remote system bus using ssh
+- Internal refactoring: Use tag dispatching to construct various types of Connection
+
+v0.7.5
+- [[Breaking ABI change]] No more hiding from C++17: Move API code containing C++17 uncaught_exceptions calls from within library to public API
+- Add a method to retrieve the unique name of a connection
+
+v0.7.6
+- Fixes of clang-8 errors and warnings
+
+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

INSTALL

@@ -1,7 +1,7 @@
 Building:
   $ mkdir build
   $ cd build
-  $ cmake .. ${CONFIGURE_FLAGS_IF_NECESSARY}
+  $ cmake .. -DCMAKE_BUILD_TYPE=Release ${OTHER_CONFIG_FLAGS}
   $ make
 
 Installing:

README.md

@@ -1,7 +1,11 @@
 sdbus-c++
 =========
 
-sdbus-c++ is a C++ API library for D-Bus IPC, based on sd-bus implementation.
+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.
+
+Even though sdbus-c++ uses sd-bus library, it is not necessarily constrained to systemd and can perfectly be used in non-systemd environments as well.
 
 Building and installing the library
 -----------------------------------
@@ -11,21 +15,60 @@ The library is built using CMake:
 ```bash
 $ mkdir build
 $ cd build
-$ cmake .. ${CONFIGURE_FLAGS_IF_NECESSARY}
+$ cmake .. -DCMAKE_BUILD_TYPE=Release ${OTHER_CONFIG_FLAGS}
 $ make
 $ sudo make install
 ```
 
-By default, the library builds its unit and integration tests. That incorporates downloading and building static libraries of Google Test. Use `-DENABLE_TESTS=OFF` configure flag if you want to disable building the tests.
+### CMake configuration flags for sdbus-c++
 
-By default, the library doesn't build the code generator for adaptor and proxy interfaces. Use `-DBUILD_CODE_GEN=ON` flag to also build the code generator.
+* `BUILD_CODE_GEN` [boolean]
+
+  Option for building the stub code generator `sdbus-c++-xml2cpp` for generating the adaptor and proxy interfaces out of the D-Bus IDL XML description. Default value: `OFF`. Use `-DBUILD_CODE_GEN=ON` flag to turn on building the code gen.
+
+* `BUILD_DOC` [boolean]
+
+  Option for including sdbus-c++ documentation files and tutorials. Default value: `ON`. With this option turned on, you may also enable/disable the following option:
+
+    * `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.
+
+* `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:
+
+    * `BUILD_PERF_TESTS` [boolean]
+
+      Option for building sdbus-c++ performance tests. Default value: `OFF`.
+
+    * `BUILD_STRESS_TESTS` [boolean]
+
+      Option for building sdbus-c++ stress tests. Default value: `OFF`.
+
+    * `TESTS_INSTALL_PATH` [string]
+
+      Path where the test binaries shall get installed. Default value: `/opt/test/bin`.
+
+* `BUILD_LIBSYSTEMD` [boolean]
+
+  Option for building libsystemd dependency library automatically when sdbus-c++ is built, and making libsystemd an integral part of sdbus-c++ library. Default value: `OFF`. Might be very helpful in non-systemd environments where libsystemd shared library is unavailable (see [Solving libsystemd dependency](docs/using-sdbus-c++.md#solving-libsystemd-dependency) for more information). With this option turned on, you may also provide the following configuration flag:
+
+    * `LIBSYSTEMD_VERSION` [string]
+
+      Defines version of systemd to be downloaded, built and integrated into sdbus-c++. Default value: `242`.
+
+* `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 :)
 
 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.
-* `libsystemd` - systemd library containing sd-bus implementation. Systemd v236 at least is needed for sdbus-c++ to compile.
-* `googletest` - google unit testing framework, only necessary when building tests, will be downloaded and built automatically
+* `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.
 
 Licensing
 ---------
@@ -35,10 +78,10 @@ The library is distributed under LGPLv2.1 license.
 References/documentation
 ------------------------
 
-* [D-Bus Specification](https://dbus.freedesktop.org/doc/dbus-specification.html)
+* [Using sdbus-c++](docs/using-sdbus-c++.md) - *the* main, comprehensive tutorial on sdbus-c++
+* [Systemd and dbus configuration](docs/systemd-dbus-config.md)
+* [D-Bus Specification](https://dbus.freedesktop.org/docs/dbus-specification.html)
 * [sd-bus Overview](http://0pointer.net/blog/the-new-sd-bus-api-of-systemd.html)
-* [Tutorial: Using sdbus-c++](doc/using-sdbus-c++.md)
-* [Systemd and dbus configuration](doc/systemd-dbus-config.md)
 
 Contributing
 ------------

cmake/LibsystemdExternalProject.cmake

@@ -0,0 +1,56 @@
+find_program(MESON meson)
+find_program(NINJA ninja)
+
+if((NOT MESON) OR (NOT NINJA))
+    message(FATAL_ERROR "Meson and Ninja are required to build libsystemd")
+endif()
+
+find_library(GLIBC_RT_LIBRARY rt)
+find_package(PkgConfig REQUIRED)
+pkg_check_modules(MOUNT mount)
+pkg_check_modules(CAP REQUIRED libcap)
+if (NOT CAP_FOUND)
+    find_library(CAP_LIBRARIES cap) # Compat with Ubuntu 14.04 which ships libcap w/o .pc file
+endif()
+
+set(LIBSYSTEMD_VERSION "242" CACHE STRING "libsystemd version (>=239) to build and incorporate into libsdbus-c++")
+
+if(NOT CMAKE_BUILD_TYPE)
+    set(LIBSYSTEMD_BUILD_TYPE "plain")
+elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    set(LIBSYSTEMD_BUILD_TYPE "debug")
+else()
+    set(LIBSYSTEMD_BUILD_TYPE "release")
+endif()
+
+if(LIBSYSTEMD_VERSION LESS "239")
+    message(FATAL_ERROR "Only libsystemd version >=239 can be built as static part of sdbus-c++")
+endif()
+if(LIBSYSTEMD_VERSION GREATER "240")
+    set(BUILD_VERSION_H ${NINJA} -C <BINARY_DIR> version.h)
+endif()
+
+include(ExternalProject)
+ExternalProject_Add(LibsystemdBuildProject
+                    PREFIX libsystemd-v${LIBSYSTEMD_VERSION}
+                    GIT_REPOSITORY    https://github.com/systemd/systemd.git
+                    GIT_TAG           v${LIBSYSTEMD_VERSION}
+                    GIT_SHALLOW       1
+                    UPDATE_COMMAND    ""
+                    CONFIGURE_COMMAND ${CMAKE_COMMAND} -E remove <BINARY_DIR>/*
+                              COMMAND ${MESON} --prefix=<INSTALL_DIR> --buildtype=${LIBSYSTEMD_BUILD_TYPE} -Dstatic-libsystemd=pic <SOURCE_DIR> <BINARY_DIR>
+                    BUILD_COMMAND     ${BUILD_VERSION_H}
+                          COMMAND     ${NINJA} -C <BINARY_DIR> libsystemd.a
+                    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)
+
+ExternalProject_Get_property(LibsystemdBuildProject SOURCE_DIR)
+ExternalProject_Get_property(LibsystemdBuildProject BINARY_DIR)
+ExternalProject_Get_property(LibsystemdBuildProject INSTALL_DIR)
+
+add_library(Systemd::Libsystemd STATIC IMPORTED)
+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

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

docs/CMakeLists.txt

@@ -0,0 +1,25 @@
+# Building doxygen documentation
+
+find_package(Doxygen)
+
+if(BUILD_DOXYGEN_DOC)
+    if(DOXYGEN_FOUND)
+        configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile @ONLY)
+
+        add_custom_target(doc
+            COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/Doxyfile
+            WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+            COMMENT "Generating API documentation with Doxygen"
+            VERBATIM)
+
+        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL)
+    else()
+        message(WARNING "Documentation enabled, but Doxygen cannot be found")
+    endif()
+endif()
+
+install(FILES sdbus-c++-class-diagram.png
+              sdbus-c++-class-diagram.uml
+              systemd-dbus-config.md
+              using-sdbus-c++.md
+        DESTINATION ${CMAKE_INSTALL_DOCDIR})

docs/sdbus-c++-class-diagram.uml

@@ -12,9 +12,10 @@ interface IObject {
   +emitSignal()
 }
 
-interface IObjectProxy {
+interface IProxy {
   +callMethod()
   +subscribeToSignal()
+  +get/setProperty()
 }
 
 class Message {
@@ -39,21 +40,24 @@ class Object {
   string objectPath
   List interfaces
   List methods
+  List signals
+  List properties
 }
 
-class ObjectProxy {
+class Proxy {
   IConnectionInternal& connection
   string destination
   string objectPath
+  List signalHandlers
 }
 
 IConnection <|-- Connection
 IConnectionInternal  <|- Connection
 IObject <|-- Object
-IObjectProxy <|-- ObjectProxy
+IProxy <|-- Proxy
 Connection <-- Object : "use"
-Connection <-- ObjectProxy : "use"
+Connection <-- Proxy : "use"
 Message <.. Object : "send/receive"
-Message <.. ObjectProxy : "send/receive"
+Message <.. Proxy : "send/receive"
 
 @enduml

docs/using-sdbus-c++.md

@@ -5,45 +5,100 @@ Using sdbus-c++ library
 
 1. [Introduction](#introduction)
 2. [Integrating sdbus-c++ into your project](#integrating-sdbus-c-into-your-project)
-3. [Header files and namespaces](#header-files-and-namespaces)
-4. [Error signalling and propagation](#error-signalling-and-propagation)
-5. [Design of sdbus-c++](#design-of-sdbus-c)
-6. [Multiple layers of sdbus-c++ API](#multiple-layers-of-sdbus-c-api)
-7. [An example: Number concatenator](#an-example-number-concatenator)
-8. [Implementing the Concatenator example using basic sdbus-c++ API layer](#implementing-the-concatenator-example-using-basic-sdbus-c-api-layer)
-9. [Implementing the Concatenator example using convenience sdbus-c++ API layer](#implementing-the-concatenator-example-using-convenience-sdbus-c-api-layer)
-10. [Implementing the Concatenator example using sdbus-c++-generated stubs](#implementing-the-concatenator-example-using-sdbus-c-generated-stubs)
-11. [Asynchronous server-side methods](#asynchronous-server-side-methods)
-12. [Asynchronous client-side methods](#asynchronous-client-side-methods)
-13. [Using D-Bus properties](#using-d-bus-properties)
-14. [Conclusion](#conclusion)
+3. [Solving libsystemd dependency](#solving-libsystemd-dependency)
+4. [Distributing sdbus-c++](#distributing-sdbus-c)
+5. [Header files and namespaces](#header-files-and-namespaces)
+6. [Error signalling and propagation](#error-signalling-and-propagation)
+7. [Design of sdbus-c++](#design-of-sdbus-c)
+8. [Multiple layers of sdbus-c++ API](#multiple-layers-of-sdbus-c-api)
+9. [An example: Number concatenator](#an-example-number-concatenator)
+10. [Implementing the Concatenator example using basic sdbus-c++ API layer](#implementing-the-concatenator-example-using-basic-sdbus-c-api-layer)
+11. [Implementing the Concatenator example using convenience sdbus-c++ API layer](#implementing-the-concatenator-example-using-convenience-sdbus-c-api-layer)
+12. [Implementing the Concatenator example using sdbus-c++-generated stubs](#implementing-the-concatenator-example-using-sdbus-c-generated-stubs)
+13. [Asynchronous server-side methods](#asynchronous-server-side-methods)
+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)
 
 Introduction
 ------------
 
-sdbus-c++ is a C++ wrapper 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 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++ 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
 ---------------------------------------
 
-The library build system is based on CMake. The library provides a config file, so integrating it into your CMake project is rather straight-forward:
+The library build system is based on CMake. The library provides a config and an export file, so integrating it into your CMake project is sooo simple:
 
-```bash
+```cmake
+# First, find sdbus-c++
 find_package(sdbus-c++ REQUIRED)
+
+# Use the sdbus-c++ target in SDBusCpp namespace
+add_executable(exe exe.cpp)
+target_link_libraries(exe PRIVATE SDBusCpp::sdbus-c++)
 ```
 
 The library also supports `pkg-config`, so it easily be integrated into e.g. an Autotools project:
 
 ```bash
-PKG_CHECK_MODULES(SDBUSCPP, [sdbus-c++ >= 0.4],,
-    AC_MSG_ERROR([You need the sdbus-c++ library (version 0.4 or newer)]
+PKG_CHECK_MODULES(SDBUSCPP, [sdbus-c++ >= 0.6],,
+    AC_MSG_ERROR([You need the sdbus-c++ library (version 0.6 or newer)]
     [http://www.kistler.com/])
 )
 ```
 
-Note: sdbus-c++ library depends on C++17, since it uses C++17 `std::uncaught_exceptions()` feature. When building sdbus-c++ manually, make sure you use a compiler that supports that feature. To use the library, make sure you have a C++ standard library that supports the feature. The feature is supported by e.g. gcc >= 6, and clang >= 3.7.
+Note: sdbus-c++ library uses a number of modern C++17 features. Please make certain you have a recent compiler (gcc >= 7, clang >= 6).
+
+Solving libsystemd dependency
+-----------------------------
+
+sdbus-c++ depends on libsystemd, a C library that is part of [systemd](https://github.com/systemd/systemd) and that contains underlying sd-bus implementation.
+
+Minimum required libsystemd shared library version is 0.20.0 (which corresponds to minimum systemd version 236).
+
+If your target Linux distribution is already based on systemd ecosystem of version 236 and higher, then there is no additional effort, just make sure you have corresponding systemd header files available (provided by `libsystemd-dev` package on Debian/Ubuntu, for example), and you may go on building sdbus-c++ seamlessly.
+
+However, sdbus-c++ can perfectly be used in non-systemd environments as well. There are two ways to approach this:
+
+### Building and distributing libsystemd as a shared library yourself
+
+Fortunately, libsystemd is rather self-contained and can be built and used independently of the rest of systemd ecosystem. To build libsystemd shared library for sdbus-c++:
+
+```shell
+$ git clone https://github.com/systemd/systemd
+$ cd systemd
+$ git checkout v242  # or any other recent stable version
+$ mkdir build
+$ cd build
+$ meson --buildtype=release .. # solve systemd dependencies if any pop up, e.g. libmount-dev, libcap, librt...
+$ ninja version.h # building version.h target is only necessary in systemd version >= 241
+$ ninja libsystemd.so.0.26.0  # or another version number depending which systemd version you have
+# finally, manually install the library, header files and libsystemd.pc pkgconfig file
+```
+
+### 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.
+
+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++
+----------------------
+
+### Yocto
+
+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:
+
+  * 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.
+
+Contributors willing to help with bringing sdbus-c++ to other popular package systems are welcome.
 
 Header files and namespaces
 ---------------------------
@@ -52,7 +107,7 @@ All sdbus-c++ header files reside in the `sdbus-c++` subdirectory within the sta
 
 ```cpp
 #include <sdbus-c++/IConnection.h>
-#include <sdbus-c++/IObjectProxy.h>
+#include <sdbus-c++/IProxy.h>
 ```
 
 or just include the global header file that pulls in everything:
@@ -80,32 +135,39 @@ 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:
 
   * registering (possibly multiple) interfaces and methods, signals, properties on those interfaces,
   * emitting signals.
 
-`IObjectProxy` represents the concept of the proxy, which is a view of the `Object` from the client side. Its responsibilities are:
+`IProxy` represents the concept of the proxy, which is a view of the `Object` from the client side. Its responsibilities are:
 
   * invoking remote methods of the corresponding object, in both synchronous and asynchronous way,
   * registering handlers for signals,
 
-`Message` class represents a message, which is the fundamental DBus concept. There are three distinctive types of message that derive from the `Message` class:
+`Message` class represents a message, which is the fundamental DBus concept. There are three distinctive types of message that are derived from the `Message` class:
 
-  * `MethodCall` (with serialized parameters),
+  * `MethodCall` (be it synchronous or asynchronous method call, with serialized parameters),
   * `MethodReply` (with serialized return values),
-  * or a `Signal` (with serialized parameters).
+  * `Signal` (with serialized parameters),
+  * `PropertySetCall` (with serialized parameter value to be set)
+  * `PropertyGetReply` (where property value shall be stored)
+  * `PlainMessage` (for internal purposes).
 
 ### Thread safety in sdbus-c++
 
-sdbus-c++ is thread-aware by design. But, in general, it's not thread-safe. At least not in all places. There are situations where sdbus-c++ provides and guarantees API-level thread safety by design. It is safe to do these operations from multiple threads at the same time:
+sdbus-c++ is completely thread-aware by design. Though sdbus-c++ is not thread-safe in general, there are situations where sdbus-c++ provides and guarantees API-level thread safety by design. It is safe to do these operations (operations within the bullet points, not across them) from multiple threads at the same time:
 
-  * Making and destroying `Object`s and `ObjectProxy`s, even on a shared connection that is already running an event loop. Under *making* here is meant a complete atomic sequence of construction, registration of method/signal/property callbacks and export of the `Object`/`ObjectProxy` so it is ready to issue/receive messages. This sequence must be done in one thread.
+  * Making or destroying distinct `Object`/`Proxy` instances simultaneously (even on a shared connection that is running an event loop already, see below). Under *making* here is meant a complete sequence of construction, registration of method/signal/property callbacks and export of the `Object`/`Proxy` so it is ready to issue/receive messages. This sequence must be completely done within the context of one thread.
   * Creating and sending asynchronous method replies on an `Object` instance.
   * Creating and emitting signals on an `Object` instance.
-  * Creating and sending method calls (both synchronously and asynchronously) on an `ObjectProxy` instance. (But it's generally better that our threads use their own exclusive instances of object proxy, to minimize shared state and contention.)
+  * Creating and sending method calls (both synchronously and asynchronously) on an `Proxy` instance. (But it's generally better that our threads use their own exclusive instances of proxy, to minimize shared state and contention.)
+
+sdbus-c++ is designed such that all the above operations are thread-safe also on a connection that is running an event loop (usually in a separate thread) at that time. It's an internal thread safety. For example, a signal arrives and is processed by sdbus-c++ even loop at an appropriate `Proxy` instance, while the user is going to destroy that instance in their application thread. The user cannot explicitly control these situations (or they could, but that would be very limiting and cubersome on the API level).
+
+However, other combinations, that the user invokes explicitly from within more threads are NOT thread-safe in sdbus-c++ by design, and the user should make sure by their design that these cases never occur. For example, destroying an `Object` instance in one thread while emitting a signal on it in another thread is not thread-safe. In this specific case, the user should make sure in their application that all threads stop working with a specific instance before a thread proceeds with deleting that instance.
 
 Multiple layers of sdbus-c++ API
 -------------------------------
@@ -115,7 +177,7 @@ sdbus-c++ API comes in two layers:
   * [the basic layer](#implementing-the-concatenator-example-using-basic-sdbus-c-api-layer), which is a simple wrapper layer on top of sd-bus, using mechanisms that are native to C++ (e.g. serialization/deserialization of data from messages),
   * [the convenience layer](#implementing-the-concatenator-example-using-convenience-sdbus-c-api-layer), building on top of the basic layer, which aims at alleviating users from unnecessary details and enables them to write shorter, safer, and more expressive code.
 
-sdbus-c++ also ships with a stub generator tool that converts D-Bus IDL in XML format into stub code for the adaptor as well as proxy part. Hierarchically, these stubs provide yet another layer of convenience (the "stubs layer"), making it possible for D-Bus RPC calls to completely look like native C++ calls on a local object.
+sdbus-c++ also ships with a stub generator tool that converts D-Bus IDL in XML format into stub code for the adaptor as well as the proxy part. Hierarchically, these stubs provide yet another layer of convenience (the "stubs layer"), making it possible for D-Bus RPC calls to completely look like native C++ calls on a local object.
 
 An example: Number concatenator
 -------------------------------
@@ -130,7 +192,7 @@ In the following sections, we will elaborate on the ways of implementing such an
 Implementing the Concatenator example using basic sdbus-c++ API layer
 ---------------------------------------------------------------------
 
-In the basic API layer, we already have abstractions for D-Bus connections, objects and object proxies, with which we can interact via their interface classes (`IConnection`, `IObject`, `IObjectProxy`), but, analogously to the underlying sd-bus C library, we still work on the level of D-Bus messages. We need to
+In the basic API layer, we already have abstractions for D-Bus connections, objects and object proxies, with which we can interact via their interface classes (`IConnection`, `IObject`, `IProxy`), but, analogously to the underlying sd-bus C library, we still work on the level of D-Bus messages. We need to
 
   * create them,
   * serialize/deserialize arguments to/from them (thanks to many overloads of C++ insertion/extraction operators, this is very simple),
@@ -150,7 +212,7 @@ This is how a simple Concatenator service implemented upon the basic sdbus-c++ A
 // to emit signals.
 sdbus::IObject* g_concatenator{};
 
-void concatenate(sdbus::MethodCall& call, sdbus::MethodReply& reply)
+void concatenate(sdbus::MethodCall call)
 {
     // Deserialize the collection of numbers from the message
     std::vector<int> numbers;
@@ -170,8 +232,10 @@ void concatenate(sdbus::MethodCall& call, sdbus::MethodReply& reply)
         result += (result.empty() ? std::string() : separator) + std::to_string(number);
     }
     
-    // Serialize resulting string to the reply
+    // 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";
@@ -198,14 +262,14 @@ int main(int argc, char *argv[])
     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();
 }
 ```
 
 We establish a D-Bus sytem connection and request `org.sdbuscpp.concatenator` D-Bus name on it. This name will be used by D-Bus clients to find the service. We then create an object with path `/org/sdbuscpp/concatenator` on this connection. We register  interfaces, its methods, signals that the object provides, and, through `finishRegistration()`, export the object (i.e., make it visible to clients) on the bus. Then we need to make sure to run the event loop upon the connection, which handles all incoming, outgoing and other requests.
 
-The callback for any D-Bus object method on this level is any callable of signature `void(sdbus::MethodCall& call, sdbus::MethodReply& reply)`. The first parameter `call` is the incoming method call message. We need to deserialize input arguments from it. When we can invoke the logic and get the results. Then we serialize the results to the second parameter, the pre-constructed `reply` message. The reply is then sent automatically by sdbus-c++. We also fire a signal with the results. To do this, we need to create a signal message via object's `createSignal()`, serialize the results into it, and then send it out to subscribers by invoking object's `emitSignal()`.
+The callback for any D-Bus object method on this level is any callable of signature `void(sdbus::MethodCall call)`. The `call` parameter is the incoming method call message. We need to deserialize our method input arguments from it. Then we can invoke the logic of the method and get the results. Then for the given `call`, we create a `reply` message, pack results into it and send it back to the caller through `send()`. (If we had a void-returning method, we'd just send an empty `reply` back.) We also fire a signal with the results. To do this, we need to create a signal message via object's `createSignal()`, serialize the results into it, and then send it out to subscribers by invoking object's `emitSignal()`.
 
 Please note that we can create and destroy D-Bus objects on a connection dynamically, at any time during runtime, even while there is an active event loop upon the connection. So managing D-Bus objects' lifecycle (creating, exporting and destroying D-Bus objects) is completely thread-safe.
 
@@ -233,7 +297,7 @@ int main(int argc, char *argv[])
     // will create its own connection automatically, and it will be system bus connection.
     const char* destinationName = "org.sdbuscpp.concatenator";
     const char* objectPath = "/org/sdbuscpp/concatenator";
-    auto concatenatorProxy = sdbus::createObjectProxy(destinationName, objectPath);
+    auto concatenatorProxy = sdbus::createProxy(destinationName, objectPath);
     
     // Let's subscribe for the 'concatenated' signals
     const char* interfaceName = "org.sdbuscpp.Concatenator";
@@ -275,7 +339,7 @@ int main(int argc, char *argv[])
 }
 ```
 
-In simple cases, we don't need to create D-Bus connection explicitly for our proxies. Unless a connection is provided to an object proxy explicitly via factory parameter, the proxy will create a connection of his own, and it will be a system bus connection. This is the case in the example above. (This approach is not scalable and resource-saving if we have plenty of proxies; see section [Working with D-Bus connections](#working-with-d-bus-connections-in-sdbus-c) for elaboration.) So, in the example, we create a proxy for object `/org/sdbuscpp/concatenator` publicly available at bus `org.sdbuscpp.concatenator`. We register signal handlers, if any, and finish the registration, making the object proxy ready for use.
+In simple cases, we don't need to create D-Bus connection explicitly for our proxies. Unless a connection is provided to a proxy object explicitly via factory parameter, the proxy will create a connection of his own, and it will be a system bus connection. This is the case in the example above. (This approach is not scalable and resource-saving if we have plenty of proxies; see section [Working with D-Bus connections](#working-with-d-bus-connections-in-sdbus-c) for elaboration.) So, in the example, we create a proxy for object `/org/sdbuscpp/concatenator` publicly available at bus `org.sdbuscpp.concatenator`. We register signal handlers, if any, and finish the registration, making the proxy ready for use.
 
 The callback for a D-Bus signal handler on this level is any callable of signature `void(sdbus::Signal& signal)`. The one and only parameter `signal` is the incoming signal message. We need to deserialize arguments from it, and then we can do our business logic with it.
 
@@ -289,27 +353,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 `Connection` 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 `Object` instance) or D-Bus object proxy (represented by one `ObjectProxy` 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 `createObjectProxy()` 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 object proxy 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
 ---------------------------------------------------------------------------
@@ -321,11 +399,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 then *how*. Let's look at code samples.
 
 ### Server side
 
@@ -377,7 +455,7 @@ int main(int argc, char *argv[])
     concatenator->finishRegistration();
 
     // Run the loop on the connection.
-    connection->enterProcessingLoop();
+    connection->enterEventLoop();
 }
 ```
 
@@ -400,7 +478,7 @@ int main(int argc, char *argv[])
     // Create proxy object for the concatenator object on the server side
     const char* destinationName = "org.sdbuscpp.concatenator";
     const char* objectPath = "/org/sdbuscpp/concatenator";
-    auto concatenatorProxy = sdbus::createObjectProxy(destinationName, objectPath);
+    auto concatenatorProxy = sdbus::createProxy(destinationName, objectPath);
     
     // Let's subscribe for the 'concatenated' signals
     const char* interfaceName = "org.sdbuscpp.Concatenator";
@@ -441,18 +519,25 @@ 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.
 
+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");
+```
+
 Implementing the Concatenator example using sdbus-c++-generated stubs
 ---------------------------------------------------------------------
 
-sdbus-c++ ships with the native stub generator tool called sdbuscpp-xml2cpp. The tool is very similar to dbusxx-xml2cpp tool that comes from 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 at server side, and a proxy header file for use at client side. Like this:
+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:
 
 ```bash
-sdbuscpp-xml2cpp database-bindings.xml --adaptor=database-server-glue.h --proxy=database-client-glue.h
+sdbus-c++-xml2cpp database-bindings.xml --adaptor=database-server-glue.h --proxy=database-client-glue.h
 ```
 
-The adaptor header file contains classes that can be used to implement described interfaces. The proxy header file contains classes that can be used to make calls to remote objects.
+The adaptor header file contains classes that can be used to implement interfaces described in the IDL (these classes represent object interfaces). The proxy header file contains classes that can be used to make calls to remote objects (these classes represent remote object interfaces).
 
 ### XML description of the Concatenator interface
 
@@ -479,11 +564,11 @@ After running this through the stubs generator, we get the stub code that is des
 
 ### concatenator-server-glue.h
 
-There is specific class for each interface in the XML IDL file. The class is de facto an interface which shall be implemented by inheriting from it. The class' constructor takes care of registering all methods, signals and properties. For each D-Bus method there is a pure virtual member function. These pure virtual functions must be implemented in the child class. For each signal, there is a public function member that emits this signal.
+For each interface in the XML IDL file the generator creates one class that represents it. The class is de facto an interface which shall be implemented by the class inheriting it. The class' constructor takes care of registering all methods, signals and properties. For each D-Bus method there is a pure virtual member function. These pure virtual functions must be implemented in the child class. For each signal, there is a public function member that emits this signal.
 
 ```cpp
 /*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
  */
 
 #ifndef __sdbuscpp__concatenator_server_glue_h__adaptor__H__
@@ -499,20 +584,22 @@ namespace sdbuscpp {
 class Concatenator_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.Concatenator";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.Concatenator";
 
 protected:
     Concatenator_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("concatenate").onInterface(interfaceName).implementedAs([this](const std::vector<int32_t>& numbers, const std::string& separator){ return this->concatenate(numbers, separator); });
-        object_.registerSignal("concatenated").onInterface(interfaceName).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;
+
 public:
-    void concatenated(const std::string& concatenatedString)
+    void emitConcatenated(const std::string& concatenatedString)
     {
-        object_.emitSignal("concatenated").onInterface(interfaceName).withArguments(concatenatedString);
+        object_.emitSignal("concatenated").onInterface(INTERFACE_NAME).withArguments(concatenatedString);
     }
 
 private:
@@ -529,11 +616,11 @@ private:
 
 ### concatenator-client-glue.h
 
-Analogously to the adaptor classes described above, there is specific class for each interface in the XML IDL file. The class is de facto a proxy to the concrete interface of a remote object. For each D-Bus signal there is a pure virtual member function whose body must be provided in a child class. For each method, there is a public function member that calls the method remotely.
+Analogously to the adaptor classes described above, there is one class generated for one interface in the XML IDL file. The class is de facto a proxy to the concrete single interface of a remote object. For each D-Bus signal there is a pure virtual member function whose body must be provided in a child class. For each method, there is a public function member that calls the method remotely.
 
 ```cpp
 /*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
  */
 
 #ifndef __sdbuscpp__concatenator_client_glue_h__proxy__H__
@@ -549,27 +636,29 @@ namespace sdbuscpp {
 class Concatenator_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.Concatenator";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.Concatenator";
 
 protected:
-    Concatenator_proxy(sdbus::IObjectProxy& object)
-        : object_(object)
+    Concatenator_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
     {
-        object_.uponSignal("concatenated").onInterface(interfaceName).call([this](const std::string& concatenatedString){ this->onConcatenated(concatenatedString); });
+        proxy_.uponSignal("concatenated").onInterface(INTERFACE_NAME).call([this](const std::string& concatenatedString){ this->onConcatenated(concatenatedString); });
     }
 
+    ~Concatenator_proxy() = default;
+
     virtual void onConcatenated(const std::string& concatenatedString) = 0;
 
 public:
     std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator)
     {
         std::string result;
-        object_.callMethod("concatenate").onInterface(interfaceName).withArguments(numbers, separator).storeResultsTo(result);
+        proxy_.callMethod("concatenate").onInterface(INTERFACE_NAME).withArguments(numbers, separator).storeResultsTo(result);
         return result;
     }
 
 private:
-    sdbus::IObjectProxy& object_;
+    sdbus::IProxy& proxy_;
 };
 
 }} // namespaces
@@ -579,18 +668,34 @@ private:
 
 ### Providing server implementation based on generated adaptors
 
-To implement a D-Bus object that implements all its D-Bus interfaces, we shall create a class representing the object that inherits from all corresponding `*_adaptor` classes and implements all pure virtual member functions. Specifically, the object class shall inherit from the `Interfaces` template class, the template arguments of which are individual adaptor classes. The `Interfaces` is just a convenience class that hides a few boiler-plate details. For example, in its constructor, it creates an `Object` instance, it takes care of proper initialization of all adaptor superclasses, and exports the object finally.
+To implement a D-Bus object that implements all its D-Bus interfaces, we now need to create a class representing the D-Bus object. This class must inherit from all corresponding `*_adaptor` classes (a-ka object interfaces, because these classes are as-if interfaces) and implement all pure virtual member functions.
+
+How do we do that technically? Simply, our object class just needs to inherit from `AdaptorInterfaces` variadic template class. We fill its template arguments with a list of all generated interface classes. The `AdaptorInterfaces` is a convenience class that hides a few boiler-plate details. For example, in its constructor, it creates an `Object` instance, and it takes care of proper initialization of all adaptor superclasses.
+
+In our object class we need to:
+
+  * Give an implementation to the D-Bus object's methods by overriding corresponding virtual functions,
+  * call `registerAdaptor()` in the constructor, which makes the adaptor (the D-Bus object underneath it) available for remote calls,
+  * call `unregisterAdaptor()`, which, conversely, unregisters the adaptor from the bus.
+
+Calling `registerAdaptor()` and `unregisterAdaptor()` was not necessary in previous sdbus-c++ versions, as it was handled by the parent class. This was convenient, but suffered from a potential pure virtual function call issue. Only the class that implements virtual functions can do the registration, hence this slight inconvenience on user's shoulders.
 
 ```cpp
 #include <sdbus-c++/sdbus-c++.h>
 #include "concatenator-server-glue.h"
 
-class Concatenator : public sdbus::Interfaces<org::sdbuscpp::Concatenator_adaptor /*, more adaptor classes if there are more interfaces*/>
+class Concatenator : public sdbus::AdaptorInterfaces<org::sdbuscpp::Concatenator_adaptor /*, more adaptor classes if there are more interfaces*/>
 {
 public:
     Concatenator(sdbus::IConnection& connection, std::string objectPath)
-        : sdbus::Interfaces<org::sdbuscpp::Concatenator_adaptor>(connection, std::move(objectPath))
+        : sdbus::AdaptorInterfaces(connection, std::move(objectPath))
     {
+        registerAdaptor();
+    }
+
+    ~Concatenator()
+    {
+        unregisterAdaptor();
     }
 
 protected:
@@ -608,7 +713,7 @@ protected:
         }
         
         // Emit the 'concatenated' signal with the resulting string
-        concatenated(result);
+        emitConcatenated(result);
         
         // Return the resulting string
         return result;
@@ -632,15 +737,25 @@ int main(int argc, char *argv[])
     Concatenator concatenator(*connection, objectPath);
 
     // Run the loop on the connection.
-    connection->enterProcessingLoop();
+    connection->enterEventLoop();
 }
 ```
 
-It's that simple :)
+Now we have a service with a unique bus name and a D-Bus object available on it. Let's write a client.
 
 ### Providing client implementation based on generated proxies
 
-To implement a proxy for a remote D-Bus object, we shall create a class representing the object proxy that inherits from all corresponding `*_proxy` classes and -- if applicable -- implements all pure virtual member functions. Specifically, the object proxy class shall inherit from the `ProxyInterfaces` template class. As its template arguments we shall provide all proxy classes. The `ProxyInterfaces` is just a convenience class that hides a few boiler-plate details. For example, in its constructor, it creates an `ObjectProxy` instance, and it takes care of proper initialization of all proxy superclasses.
+To implement a proxy for a remote D-Bus object, we shall create a class representing the proxy object. This class must inherit from all corresponding `*_proxy` classes (a-ka remote object interfaces, because these classes are as-if interfaces) and -- if applicable -- implement all pure virtual member functions.
+
+How do we do that technically? Simply, our proxy class just needs to inherit from `ProxyInterfaces` variadic template class. We fill its template arguments with a list of all generated interface classes. The `ProxyInterfaces` is a convenience class that hides a few boiler-plate details. For example, in its constructor, it can create a `Proxy` instance for us, and it takes care of proper initialization of all generated interface superclasses.
+
+In our proxy class we need to:
+
+  * Give an implementation to signal handlers and asynchronous method reply handlers (if any) by overriding corresponding virtual functions,
+  * call `registerProxy()` in the constructor, which makes the proxy (the D-Bus proxy object underneath it) ready to receive signals and async call replies,
+  * call `unregisterProxy()`, which, conversely, unregisters the proxy from the bus.
+
+Calling `registerProxy()` and `unregisterProxy()` was not necessary in previous versions of sdbus-c++, as it was handled by the parent class. This was convenient, but suffered from a potential pure virtual function call issue. Only the class that implements virtual functions can do the registration, hence this slight inconvenience on user's shoulders.
 
 ```cpp
 #include <sdbus-c++/sdbus-c++.h>
@@ -650,8 +765,14 @@ class ConcatenatorProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::Concatena
 {
 public:
     ConcatenatorProxy(std::string destination, std::string objectPath)
-        : sdbus::ProxyInterfaces<org::sdbuscpp::Concatenator_proxy>(std::move(destination), std::move(objectPath))
+        : sdbus::ProxyInterfaces(std::move(destination), std::move(objectPath))
     {
+        registerProxy();
+    }
+
+    ~Concatenator()
+    {
+        unregisterProxy();
     }
 
 protected:
@@ -662,9 +783,9 @@ protected:
 };
 ```
 
-In the above example, a proxy is created that creates and maintains its own system bus connection. However, there are `ProxyInterfaces` class template constructor overloads that also take the connection from the user as the first parameter, and pass that connection over to the underlying proxy. The connection instance is used for all D-Bus proxy interfaces listed in the `ProxyInterfaces` template parameter list.
+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::createObjectProxy` overloads, as they are actually implemented on top of them. See [Proxy and D-Bus connection](#Proxy-and-D-Bus-connection) for more info.
+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.
 
 Now let's use this proxy to make remote calls and listen to signals in a real application.
 
@@ -709,12 +830,12 @@ Asynchronous server-side methods
 
 So far in our tutorial, we have only considered simple server methods that are executed in a synchronous way. Sometimes the method call may take longer, however, and we don't want to block (potentially starve) other clients (whose requests may take relative short time). The solution is to execute the D-Bus methods asynchronously, and return the control quickly back to the D-Bus dispatching thread. sdbus-c++ provides API supporting async methods, and gives users the freedom to come up with their own concrete implementation mechanics (one worker thread? thread pool? ...).
 
-### Lower-level API
+### Using basic sdbus-c++ API
 
-Considering the Concatenator example based on lower-level API, if we wanted to write `concatenate` method in an asynchronous way, you only have to adapt method signature and its body (registering the method and all the other stuff stays the same):
+This is how the concatenate method would look like if wrote it as an asynchronous D-Bus method using the basic, lower-level API of sdbus-c++:
 
 ```c++
-void concatenate(sdbus::MethodCall& call, sdbus::MethodResult result)
+void concatenate(sdbus::MethodCall call)
 {
     // Deserialize the collection of numbers from the message
     std::vector<int> numbers;
@@ -725,62 +846,84 @@ void concatenate(sdbus::MethodCall& call, sdbus::MethodResult result)
     call >> separator;
     
     // Launch a thread for async execution...
-    std::thread([numbers, separator, result = std::move(result)]()
+    std::thread([numbers = std::move(numbers), separator = std::move(separator), call = std::move(call)]()
     {
         // Return error if there are no numbers in the collection
         if (numbers.empty())
         {
-            // This will send the error reply message back to the client
-            result.returnError("org.sdbuscpp.Concatenator.Error", "No numbers provided");
+            // Let's send the error reply message back to the client
+            auto reply = call.createErrorReply({"org.sdbuscpp.Concatenator.Error", "No numbers provided"});
+            reply.send();
             return;
         }
         
-        std::string concatenatedStr;
+        std::string result;
         for (auto number : numbers)
         {
-            concatenatedStr += (result.empty() ? std::string() : separator) + std::to_string(number);
+            result += (result.empty() ? std::string() : separator) + std::to_string(number);
         }
         
-        // This will send the reply message back to the client
-        result.returnResults(concatenatedStr);
+        // Let's send the reply message back to the client
+        auto reply = call.createReply();
+        reply << result;
+        reply.send();
         
-        // Note: emitting signals from other than D-Bus dispatcher thread is not supported yet...
-        /*
-        // Emit 'concatenated' signal
+        // Emit 'concatenated' signal (creating and emitting signals is thread-safe)
         const char* interfaceName = "org.sdbuscpp.Concatenator";
         auto signal = g_concatenator->createSignal(interfaceName, "concatenated");
         signal << result;
         g_concatenator->emitSignal(signal);
-        */
     }).detach();
 }
 ```
 
-Notice these differences as compared to the synchronous version:
+There are a few slight differences compared to the synchronous version. Notice that we `std::move` the `call` message to the worker thread (btw we might also do input arguments deserialization in the worker thread, we don't have to do it in the current thread and then move input arguments to the worker thread...). We need the `call` message there to create the reply message once we have the (normal or error) result. Creating and sending replies, as well as creating and emitting signals is thread-safe by design. Also notice that, unlike in sync methods, sending back errors cannot be done by throwing `Error`, since we are now in the context of the worker thread, not that of the D-Bus dispatcher thread. Instead, we pass the `Error` object to the `createErrorReply()` method of the call message (this way of sending back errors, in addition to throwing, we can actually use also in classic synchronous D-Bus methods).
 
-  * Instead of `MethodReply` message given by reference, there is `MethodResult` as a second parameter of the callback, which will hold method results and can be written to from any thread.
-
-  * You shall pass the result holder (`MethodResult` instance) by moving it to the thread of execution, and eventually write method results (or method error) to it via its `returnResults()` or `returnError()` method, respectively.
-
-  * Unlike in sync methods, reporting errors cannot be done by throwing sdbus::Error, since the execution takes place out of context of the D-Bus dispatcher thread. Instead, just pass the error name and message to the `returnError` method of the result holder.
-
-That's all.
+Method callback signature is the same in sync and async version. That means sdbus-c++ doesn't care how we execute our D-Bus method. We might very well in run-time decide whether we execute it synchronously, or whether (perhaps in case of longer, more complex calculations) we move the execution to a worker thread.
 
 ### Convenience API
 
-Method callbacks in convenience sdbus-c++ API also need to take the result object as a parameter. The requirements are:
+Callbacks of async methods based on convenience sdbus-c++ API have slightly different signature. They take a result object parameter in addition to other input parameters. The requirements are:
 
-  * The result holder is of type `sdbus::Result<Types...>`, where `Types...` is a list of method output argument types.
-  * The result object must be a first physical parameter of the callback taken by value.
+  * The result holder is of type `Result<Types...>&&`, where `Types...` is a list of method output argument types.
+  * The result object must be the first physical parameter of the callback taken by r-value ref. `Result` class template is move-only.
   * The callback itself is physically a void-returning function.
+  * Method input arguments are taken by value rathern than by const ref, because we usually want to `std::move` them to the worker thread. Moving is usually a lot cheaper than copying, and it's idiomatic. For non-movable types, this falls back to copying.
 
-For example, we would have to change the concatenate callback signature from `std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator)` to `void concatenate(sdbus::Result<std::string> result, const std::vector<int32_t>& numbers, const std::string& separator)`.
+So the concatenate callback signature would change from `std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator)` to `void concatenate(sdbus::Result<std::string>&& result, std::vector<int32_t> numbers, std::string separator)`:
 
-`sdbus::Result` class template has effectively the same API as `sdbus::MethodResult` class mentioned in the above example (it inherits from `MethodResult`), so you use it in the very same way to send the results or an error back to the client.
+```c++
+void concatenate(sdbus::Result<std::string>&& result, std::vector<int32_t> numbers, std::string separator) override
+{
+    // Launch a thread for async execution...
+    std::thread([this, methodResult = std::move(result), numbers = std::move(numbers), separator = std::move(separator)]()
+    {
+        // Return error if there are no numbers in the collection
+        if (numbers.empty())
+        {
+            // Let's send the error reply message back to the client
+            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);
+        
+        // Emit the 'concatenated' signal with the resulting string
+        this->emitConcatenated(result);
+    }).detach();
+}
+```
 
-Nothing else has to be changed. The registration of the method callback (`implementedAs`) and all the mechanics around remains completely the same.
+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.
 
-Note: Async D-Bus method doesn't necessarily mean we always have to delegate the work to a different thread and immediately return. We can very well execute the work and return the results (via `returnResults()`) or an error (via `return Error()`) synchronously -- i.e. directly in this thread. dbus-c++ doesn't care, it supports both approaches. This has the benefit that we can decide at run-time, per each method call, whether we execute it synchronously or (in case of complex operation, for example) execute it asynchronously by moving the work to a worker thread.
+Registraion (`implementedAs()`) doesn't change. Nothing else needs to change.
 
 ### Marking server-side async methods in the IDL
 
@@ -804,6 +947,8 @@ sdbus-c++ stub generator can generate stub code for server-side async methods. W
 </node>
 ```
 
+For a real example of a server-side asynchronous D-Bus method, please look at sdbus-c++ [stress tests](/tests/stresstests).
+
 Asynchronous client-side methods
 --------------------------------
 
@@ -919,12 +1064,14 @@ For each client-side async method, a corresponding `on<MethodName>Reply` pure vi
     
 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).
+
 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’.
 
@@ -958,12 +1105,14 @@ public:
         object_.registerProperty("status").onInterface(INTERFACE_NAME).withGetter([this](){ return this->status(); }).withSetter([this](const uint32_t& value){ this->status(value); });
     }
 
+    ~PropertyProvider_adaptor() = default;
+
 private:
     // property getter
     virtual uint32_t status() = 0;
     // property setter
     virtual void status(const uint32_t& value) = 0;
-    
+
     /*...*/
 };
 #endif
@@ -975,7 +1124,7 @@ The proxy:
 class PropertyProvider_proxy
 {
     /*...*/
-    
+
 public:
     // getting the property value
     uint32_t status()
@@ -988,13 +1137,31 @@ public:
     {
         object_.setProperty("status").onInterface(INTERFACE_NAME).toValue(value);
     }
-    
+
     /*...*/
 };
 ```
 
 When implementing the adaptor, we simply need to provide the body for `status` getter and setter method by overriding them. Then in the proxy, we just call them.
 
+Standard D-Bus interfaces
+-------------------------
+
+sdbus-c++ provides support for standard D-Bus interfaces. These are:
+
+* `org.freedesktop.DBus.Peer`
+* `org.freedesktop.DBus.Introspectable`
+* `org.freedesktop.DBus.Properties`
+* `org.freedesktop.DBus.ObjectManager`
+
+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.
+
+For example, to conveniently emit a `PropertyChanged` signal under `org.freedesktop.DBus.Properties` interface, 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.
+
 Conclusion
 ----------
 

include/sdbus-c++/AdaptorInterfaces.h

@@ -0,0 +1,148 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file AdaptorInterfaces.h
+ *
+ * Created on: Nov 8, 2016
+ * 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_ADAPTORINTERFACES_H_
+#define SDBUS_CXX_ADAPTORINTERFACES_H_
+
+#include <sdbus-c++/IObject.h>
+#include <cassert>
+#include <string>
+#include <memory>
+
+// Forward declarations
+namespace sdbus {
+    class IConnection;
+}
+
+namespace sdbus {
+
+    /********************************************//**
+     * @class ObjectHolder
+     *
+     * ObjectHolder is a helper that simply owns and provides
+     * access to an object to other classes in the inheritance
+     * hierarchy of an object based on generated interface classes.
+     *
+     ***********************************************/
+    class ObjectHolder
+    {
+    protected:
+        ObjectHolder(std::unique_ptr<IObject>&& object)
+            : object_(std::move(object))
+        {
+        }
+
+        const IObject& getObject() const
+        {
+            assert(object_ != nullptr);
+            return *object_;
+        }
+
+        IObject& getObject()
+        {
+            assert(object_ != nullptr);
+            return *object_;
+        }
+
+    private:
+        std::unique_ptr<IObject> object_;
+    };
+
+    /********************************************//**
+     * @class AdaptorInterfaces
+     *
+     * AdaptorInterfaces is a helper template class that joins all interface classes of a remote
+     * D-Bus object generated by sdbus-c++-xml2cpp to be used on the server (the adaptor) side,
+     * including some auxiliary classes. AdaptorInterfaces is the class that native-like object
+     * implementation classes written by users should inherit from and implement all pure virtual
+     * methods. So the _Interfaces template parameter is a list of sdbus-c++-xml2cpp-generated
+     * adaptor-side interface classes representing interfaces (with methods, signals and properties)
+     * of the D-Bus object.
+     *
+     * In the final adaptor class inherited from AdaptorInterfaces, it is necessary to finish
+     * adaptor registration in class constructor (finishRegistration();`), and, conversely,
+     * unregister the adaptor in class destructor (`unregister();`).
+     *
+     ***********************************************/
+    template <typename... _Interfaces>
+    class AdaptorInterfaces
+        : protected ObjectHolder
+        , public _Interfaces...
+    {
+    public:
+        /*!
+         * @brief Creates object instance
+         *
+         * @param[in] connection D-Bus connection where the object will publish itself
+         * @param[in] objectPath Path of the D-Bus object
+         *
+         * For more information, consult @ref createObject(sdbus::IConnection&,std::string)
+         */
+        AdaptorInterfaces(IConnection& connection, std::string objectPath)
+            : ObjectHolder(createObject(connection, std::move(objectPath)))
+            , _Interfaces(getObject())...
+        {
+        }
+
+        /*!
+         * @brief Finishes adaptor API registration and publishes the adaptor on the bus
+         *
+         * This function must be called in the constructor of the final adaptor class that implements AdaptorInterfaces.
+         *
+         * For more information, see underlying @ref IObject::finishRegistration()
+         */
+        void registerAdaptor()
+        {
+            getObject().finishRegistration();
+        }
+
+        /*!
+         * @brief Unregisters adaptors's API and removes it from the bus
+         *
+         * This function must be called in the destructor of the final adaptor class that implements AdaptorInterfaces.
+         *
+         * For more information, see underlying @ref IObject::unregister()
+         */
+        void unregisterAdaptor()
+        {
+            getObject().unregister();
+        }
+
+        /*!
+         * @brief Returns object path of the underlying DBus object
+         */
+        const std::string& getObjectPath() const
+        {
+            return getObject().getObjectPath();
+        }
+
+    protected:
+        using base_type = AdaptorInterfaces;
+    };
+
+}
+
+#endif /* SDBUS_CXX_ADAPTORINTERFACES_H_ */

include/sdbus-c++/ConvenienceApiClasses.h

@@ -1,7 +1,8 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
- * @file ConvenienceClasses.h
+ * @file ConvenienceApiClasses.h
  *
  * Created on: Jan 19, 2017
  * Project: sdbus-c++
@@ -23,21 +24,25 @@
  * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SDBUS_CXX_CONVENIENCECLASSES_H_
-#define SDBUS_CXX_CONVENIENCECLASSES_H_
+#ifndef SDBUS_CXX_CONVENIENCEAPICLASSES_H_
+#define SDBUS_CXX_CONVENIENCEAPICLASSES_H_
 
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Flags.h>
 #include <string>
+#include <vector>
 #include <type_traits>
+#include <chrono>
+#include <cstdint>
 
 // Forward declarations
 namespace sdbus {
     class IObject;
-    class IObjectProxy;
+    class IProxy;
     class Variant;
     class Error;
+    class PendingAsyncCall;
 }
 
 namespace sdbus {
@@ -47,14 +52,14 @@ namespace sdbus {
     public:
         MethodRegistrator(IObject& object, const std::string& methodName);
         MethodRegistrator(MethodRegistrator&& other) = default;
-        MethodRegistrator& operator=(MethodRegistrator&& other) = default;
         ~MethodRegistrator() noexcept(false);
 
-        MethodRegistrator& onInterface(const std::string& interfaceName);
-        template <typename _Function>
-        std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
-        template <typename _Function>
-        std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
+        MethodRegistrator& onInterface(std::string interfaceName);
+        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();
@@ -64,9 +69,10 @@ namespace sdbus {
         const std::string& methodName_;
         std::string interfaceName_;
         std::string inputSignature_;
+        std::vector<std::string> inputParamNames_;
         std::string outputSignature_;
-        method_callback syncCallback_;
-        async_method_callback asyncCallback_;
+        std::vector<std::string> outputParamNames_;
+        method_callback methodCallback_;
         Flags flags_;
         int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
     };
@@ -76,11 +82,12 @@ namespace sdbus {
     public:
         SignalRegistrator(IObject& object, const std::string& signalName);
         SignalRegistrator(SignalRegistrator&& other) = default;
-        SignalRegistrator& operator=(SignalRegistrator&& other) = default;
         ~SignalRegistrator() noexcept(false);
 
         SignalRegistrator& onInterface(std::string interfaceName);
         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
     };
@@ -97,10 +105,9 @@ namespace sdbus {
     public:
         PropertyRegistrator(IObject& object, const std::string& propertyName);
         PropertyRegistrator(PropertyRegistrator&& other) = default;
-        PropertyRegistrator& operator=(PropertyRegistrator&& other) = default;
         ~PropertyRegistrator() noexcept(false);
 
-        PropertyRegistrator& onInterface(const std::string& interfaceName);
+        PropertyRegistrator& onInterface(std::string interfaceName);
         template <typename _Function> PropertyRegistrator& withGetter(_Function&& callback);
         template <typename _Function> PropertyRegistrator& withSetter(_Function&& callback);
         PropertyRegistrator& markAsDeprecated();
@@ -123,7 +130,6 @@ namespace sdbus {
     public:
         InterfaceFlagsSetter(IObject& object, const std::string& interfaceName);
         InterfaceFlagsSetter(InterfaceFlagsSetter&& other) = default;
-        InterfaceFlagsSetter& operator=(InterfaceFlagsSetter&& other) = default;
         ~InterfaceFlagsSetter() noexcept(false);
 
         InterfaceFlagsSetter& markAsDeprecated();
@@ -143,7 +149,6 @@ namespace sdbus {
     public:
         SignalEmitter(IObject& object, const std::string& signalName);
         SignalEmitter(SignalEmitter&& other) = default;
-        SignalEmitter& operator=(SignalEmitter&& other) = default;
         ~SignalEmitter() noexcept(false);
         SignalEmitter& onInterface(const std::string& interfaceName);
         template <typename... _Args> void withArguments(_Args&&... args);
@@ -158,20 +163,23 @@ namespace sdbus {
     class MethodInvoker
     {
     public:
-        MethodInvoker(IObjectProxy& objectProxy, const std::string& methodName);
+        MethodInvoker(IProxy& proxy, const std::string& methodName);
         MethodInvoker(MethodInvoker&& other) = default;
-        MethodInvoker& operator=(MethodInvoker&& other) = default;
         ~MethodInvoker() noexcept(false);
 
         MethodInvoker& onInterface(const std::string& interfaceName);
+        MethodInvoker& withTimeout(uint64_t usec);
+        template <typename _Rep, typename _Period>
+        MethodInvoker& withTimeout(const std::chrono::duration<_Rep, _Period>& timeout);
         template <typename... _Args> MethodInvoker& withArguments(_Args&&... args);
         template <typename... _Args> void storeResultsTo(_Args&... args);
 
         void dontExpectReply();
 
     private:
-        IObjectProxy& objectProxy_;
+        IProxy& proxy_;
         const std::string& methodName_;
+        uint64_t timeout_{};
         MethodCall method_;
         int exceptions_{}; // Number of active exceptions when MethodInvoker is constructed
         bool methodCalled_{};
@@ -180,54 +188,59 @@ namespace sdbus {
     class AsyncMethodInvoker
     {
     public:
-        AsyncMethodInvoker(IObjectProxy& objectProxy, const std::string& methodName);
+        AsyncMethodInvoker(IProxy& proxy, const std::string& methodName);
         AsyncMethodInvoker& onInterface(const std::string& interfaceName);
+        AsyncMethodInvoker& withTimeout(uint64_t usec);
+        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:
-        IObjectProxy& objectProxy_;
+        IProxy& proxy_;
         const std::string& methodName_;
-        AsyncMethodCall method_;
+        uint64_t timeout_{};
+        MethodCall method_;
     };
 
     class SignalSubscriber
     {
     public:
-        SignalSubscriber(IObjectProxy& objectProxy, const std::string& signalName);
-        SignalSubscriber& onInterface(const std::string& interfaceName);
+        SignalSubscriber(IProxy& proxy, const std::string& signalName);
+        SignalSubscriber& onInterface(std::string interfaceName);
         template <typename _Function> void call(_Function&& callback);
 
     private:
-        IObjectProxy& objectProxy_;
-        std::string signalName_;
+        IProxy& proxy_;
+        const std::string& signalName_;
         std::string interfaceName_;
     };
 
     class PropertyGetter
     {
     public:
-        PropertyGetter(IObjectProxy& objectProxy, const std::string& propertyName);
+        PropertyGetter(IProxy& proxy, const std::string& propertyName);
         sdbus::Variant onInterface(const std::string& interfaceName);
 
     private:
-        IObjectProxy& objectProxy_;
-        std::string propertyName_;
+        IProxy& proxy_;
+        const std::string& propertyName_;
     };
 
     class PropertySetter
     {
     public:
-        PropertySetter(IObjectProxy& objectProxy, const std::string& propertyName);
-        PropertySetter& onInterface(const std::string& interfaceName);
+        PropertySetter(IProxy& proxy, const std::string& propertyName);
+        PropertySetter& onInterface(std::string interfaceName);
         template <typename _Value> void toValue(const _Value& value);
+        void toValue(const sdbus::Variant& value);
 
     private:
-        IObjectProxy& objectProxy_;
+        IProxy& proxy_;
         const std::string& propertyName_;
         std::string interfaceName_;
     };
 
 }
 
-#endif /* SDBUS_CXX_CONVENIENCECLASSES_H_ */
+#endif /* SDBUS_CXX_CONVENIENCEAPICLASSES_H_ */

include/sdbus-c++/ConvenienceApiClasses.inl

@@ -1,7 +1,8 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
- * @file ConvenienceClasses.inl
+ * @file ConvenienceApiClasses.inl
  *
  * Created on: Dec 19, 2016
  * Project: sdbus-c++
@@ -23,11 +24,11 @@
  * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#ifndef SDBUS_CPP_CONVENIENCECLASSES_INL_
-#define SDBUS_CPP_CONVENIENCECLASSES_INL_
+#ifndef SDBUS_CPP_CONVENIENCEAPICLASSES_INL_
+#define SDBUS_CPP_CONVENIENCEAPICLASSES_INL_
 
 #include <sdbus-c++/IObject.h>
-#include <sdbus-c++/IObjectProxy.h>
+#include <sdbus-c++/IProxy.h>
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/MethodResult.h>
 #include <sdbus-c++/Types.h>
@@ -35,16 +36,19 @@
 #include <sdbus-c++/Error.h>
 #include <string>
 #include <tuple>
-/*#include <exception>*/
+#include <exception>
+#include <cassert>
 
 namespace sdbus {
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
+    /*** ----------------- ***/
+    /*** MethodRegistrator ***/
+    /*** ----------------- ***/
+
     inline MethodRegistrator::MethodRegistrator(IObject& object, const std::string& methodName)
         : object_(object)
         , methodName_(methodName)
-        , exceptions_(std::uncaught_exceptions()) // Needs C++17
+        , exceptions_(std::uncaught_exceptions())
     {
     }
 
@@ -54,7 +58,8 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus method", EINVAL);
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
+        assert(methodCallback_); // implementedAs() must be placed/called prior to this function
 
         // registerMethod() can throw. But as the MethodRegistrator shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
@@ -65,70 +70,88 @@ 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.
-        if (syncCallback_)
-            object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(syncCallback_));
-        else if(asyncCallback_)
-            object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(asyncCallback_));
-        else
-            SDBUS_THROW_ERROR("Method handler not specified when registering a DBus method", EINVAL);
+        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(const std::string& interfaceName)
+    inline MethodRegistrator& MethodRegistrator::onInterface(std::string interfaceName)
     {
-        interfaceName_ = interfaceName;
+        interfaceName_ = std::move(interfaceName);
 
         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();
-        syncCallback_ = [callback = std::forward<_Function>(callback)](MethodCall& msg, MethodReply& reply)
-        {
-            // Create a tuple of callback input arguments' types, which will be used
-            // as a storage for the argument values deserialized from the message.
-            tuple_of_function_input_arg_types_t<_Function> inputArgs;
-
-            // Deserialize input arguments from the message into the tuple
-            msg >> 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.
-            reply << ret;
-        };
-
-        return *this;
-    }
-
-    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();
-        asyncCallback_ = [callback = std::forward<_Function>(callback)](MethodCall msg, MethodResult&& result)
+        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.
-            msg >> inputArgs;
+            call >> inputArgs;
 
-            // Invoke callback with input arguments from the tuple.
-            sdbus::apply(callback, std::move(result), std::move(inputArgs)); // TODO: Use std::apply when switching to full C++17 support
+            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);
@@ -150,12 +173,13 @@ namespace sdbus {
         return *this;
     }
 
+    /*** ----------------- ***/
+    /*** SignalRegistrator ***/
+    /*** ----------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
-    inline SignalRegistrator::SignalRegistrator(IObject& object, std::string signalName)
+    inline SignalRegistrator::SignalRegistrator(IObject& object, const std::string& signalName)
         : object_(object)
-        , signalName_(std::move(signalName))
+        , signalName_(signalName)
         , exceptions_(std::uncaught_exceptions())
     {
     }
@@ -166,8 +190,7 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        if (interfaceName_.empty())
-            throw sdbus::Exception("DBus interface not specified when registering a DBus signal");
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
 
         // registerSignal() can throw. But as the SignalRegistrator shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
@@ -178,9 +201,12 @@ namespace sdbus {
         // Therefore, we can allow registerSignal() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerSignal(interfaceName_, signalName_, signalSignature_);
+        object_.registerSignal( interfaceName_
+                              , 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);
@@ -204,12 +247,13 @@ namespace sdbus {
         return *this;
     }
 
+    /*** ------------------- ***/
+    /*** PropertyRegistrator ***/
+    /*** ------------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
-    inline PropertyRegistrator::PropertyRegistrator(IObject& object, std::string propertyName)
+    inline PropertyRegistrator::PropertyRegistrator(IObject& object, const std::string& propertyName)
         : object_(object)
-        , propertyName_(std::move(propertyName))
+        , propertyName_(propertyName)
         , exceptions_(std::uncaught_exceptions())
     {
     }
@@ -220,7 +264,7 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when registering a DBus property", EINVAL);
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
 
         // registerProperty() can throw. But as the PropertyRegistrator shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
@@ -231,17 +275,17 @@ namespace sdbus {
         // Therefore, we can allow registerProperty() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerProperty( std::move(interfaceName_)
-                                , std::move(propertyName_)
-                                , std::move(propertySignature_)
+        object_.registerProperty( interfaceName_
+                                , propertyName_
+                                , propertySignature_
                                 , std::move(getter_)
-                                , std::move(setter_) );
+                                , std::move(setter_)
+                                , flags_ );
     }
-    */
 
-    inline PropertyRegistrator& PropertyRegistrator::onInterface(const std::string& interfaceName)
+    inline PropertyRegistrator& PropertyRegistrator::onInterface(std::string interfaceName)
     {
-        interfaceName_ = interfaceName;
+        interfaceName_ = std::move(interfaceName);
 
         return *this;
     }
@@ -255,10 +299,10 @@ namespace sdbus {
         if (propertySignature_.empty())
             propertySignature_ = signature_of_function_output_arguments<_Function>::str();
 
-        getter_ = [callback = std::forward<_Function>(callback)](Message& msg)
+        getter_ = [callback = std::forward<_Function>(callback)](PropertyGetReply& reply)
         {
-            // Get the propety value and serialize it into the message
-            msg << callback();
+            // Get the propety value and serialize it into the pre-constructed reply message
+            reply << callback();
         };
 
         return *this;
@@ -273,14 +317,14 @@ namespace sdbus {
         if (propertySignature_.empty())
             propertySignature_ = signature_of_function_input_arguments<_Function>::str();
 
-        setter_ = [callback = std::forward<_Function>(callback)](Message& msg)
+        setter_ = [callback = std::forward<_Function>(callback)](PropertySetCall& call)
         {
             // Default-construct property value
             using property_type = function_argument_t<_Function, 0>;
             std::decay_t<property_type> property;
 
-            // Deserialize property value from the message
-            msg >> property;
+            // Deserialize property value from the incoming call message
+            call >> property;
 
             // Invoke setter with the value
             callback(property);
@@ -310,9 +354,10 @@ namespace sdbus {
         return *this;
     }
 
+    /*** -------------------- ***/
+    /*** InterfaceFlagsSetter ***/
+    /*** -------------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
     inline InterfaceFlagsSetter::InterfaceFlagsSetter(IObject& object, const std::string& interfaceName)
         : object_(object)
         , interfaceName_(interfaceName)
@@ -326,8 +371,6 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when setting its flags", EINVAL);
-
         // setInterfaceFlags() can throw. But as the InterfaceFlagsSetter shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
         // shall never happen. I.e. it should not happen that this destructor is directly called
@@ -337,10 +380,8 @@ namespace sdbus {
         // Therefore, we can allow setInterfaceFlags() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.setInterfaceFlags( std::move(interfaceName_)
-                                 , std::move(flags_) );
+        object_.setInterfaceFlags(interfaceName_, std::move(flags_));
     }
-    */
 
     inline InterfaceFlagsSetter& InterfaceFlagsSetter::markAsDeprecated()
     {
@@ -370,9 +411,10 @@ namespace sdbus {
         return *this;
     }
 
+    /*** ------------- ***/
+    /*** SignalEmitter ***/
+    /*** ------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
     inline SignalEmitter::SignalEmitter(IObject& object, const std::string& signalName)
         : object_(object)
         , signalName_(signalName)
@@ -386,9 +428,6 @@ namespace sdbus {
         if (std::uncaught_exceptions() != exceptions_)
             return;
 
-        if (!signal_.isValid())
-            throw sdbus::Exception("DBus interface not specified when emitting a DBus signal");
-
         // emitSignal() can throw. But as the SignalEmitter shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
         // shall never happen. I.e. it should not happen that this destructor is directly called
@@ -400,7 +439,6 @@ namespace sdbus {
         // to the exception thrown from here if the caller is a destructor itself.
         object_.emitSignal(signal_);
     }
-    */
 
     inline SignalEmitter& SignalEmitter::onInterface(const std::string& interfaceName)
     {
@@ -412,16 +450,17 @@ namespace sdbus {
     template <typename... _Args>
     inline void SignalEmitter::withArguments(_Args&&... args)
     {
-        SDBUS_THROW_ERROR_IF(!signal_.isValid(), "DBus interface not specified when emitting a DBus signal", EINVAL);
+        assert(signal_.isValid()); // onInterface() must be placed/called prior to withArguments()
 
         detail::serialize_pack(signal_, std::forward<_Args>(args)...);
     }
 
+    /*** ------------- ***/
+    /*** MethodInvoker ***/
+    /*** ------------- ***/
 
-    // Moved into the library to isolate from C++17 dependency
-    /*
-    inline MethodInvoker::MethodInvoker(IObjectProxy& objectProxy, const std::string& methodName)
-        : objectProxy_(objectProxy)
+    inline MethodInvoker::MethodInvoker(IProxy& proxy, const std::string& methodName)
+        : proxy_(proxy)
         , methodName_(methodName)
         , exceptions_(std::uncaught_exceptions())
     {
@@ -434,9 +473,6 @@ namespace sdbus {
         if (methodCalled_ || std::uncaught_exceptions() != exceptions_)
             return;
 
-        if (!method_.isValid())
-            throw sdbus::Exception("DBus interface not specified when calling a DBus method");
-
         // callMethod() can throw. But as the MethodInvoker shall always be used as an unnamed,
         // temporary object, i.e. not as a stack-allocated object, the double-exception situation
         // shall never happen. I.e. it should not happen that this destructor is directly called
@@ -446,21 +482,34 @@ namespace sdbus {
         // Therefore, we can allow callMethod() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        objectProxy_.callMethod(method_);
+        proxy_.callMethod(method_, timeout_);
     }
-    */
 
     inline MethodInvoker& MethodInvoker::onInterface(const std::string& interfaceName)
     {
-        method_ = objectProxy_.createMethodCall(interfaceName, methodName_);
+        method_ = proxy_.createMethodCall(interfaceName, methodName_);
 
         return *this;
     }
 
+    inline MethodInvoker& MethodInvoker::withTimeout(uint64_t usec)
+    {
+        timeout_ = usec;
+
+        return *this;
+    }
+
+    template <typename _Rep, typename _Period>
+    inline MethodInvoker& MethodInvoker::withTimeout(const std::chrono::duration<_Rep, _Period>& timeout)
+    {
+        auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
+        return withTimeout(microsecs.count());
+    }
+
     template <typename... _Args>
     inline MethodInvoker& MethodInvoker::withArguments(_Args&&... args)
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
         detail::serialize_pack(method_, std::forward<_Args>(args)...);
 
@@ -470,9 +519,9 @@ namespace sdbus {
     template <typename... _Args>
     inline void MethodInvoker::storeResultsTo(_Args&... args)
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
-        auto reply = objectProxy_.callMethod(method_);
+        auto reply = proxy_.callMethod(method_, timeout_);
         methodCalled_ = true;
 
         detail::deserialize_pack(reply, args...);
@@ -480,29 +529,46 @@ namespace sdbus {
 
     inline void MethodInvoker::dontExpectReply()
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
         method_.dontExpectReply();
     }
 
+    /*** ------------------ ***/
+    /*** AsyncMethodInvoker ***/
+    /*** ------------------ ***/
 
-    inline AsyncMethodInvoker::AsyncMethodInvoker(IObjectProxy& objectProxy, const std::string& methodName)
-        : objectProxy_(objectProxy)
+    inline AsyncMethodInvoker::AsyncMethodInvoker(IProxy& proxy, const std::string& methodName)
+        : proxy_(proxy)
         , methodName_(methodName)
     {
     }
 
     inline AsyncMethodInvoker& AsyncMethodInvoker::onInterface(const std::string& interfaceName)
     {
-        method_ = objectProxy_.createAsyncMethodCall(interfaceName, methodName_);
+        method_ = proxy_.createMethodCall(interfaceName, methodName_);
 
         return *this;
     }
 
+    inline AsyncMethodInvoker& AsyncMethodInvoker::withTimeout(uint64_t usec)
+    {
+        timeout_ = usec;
+
+        return *this;
+    }
+
+    template <typename _Rep, typename _Period>
+    inline AsyncMethodInvoker& AsyncMethodInvoker::withTimeout(const std::chrono::duration<_Rep, _Period>& timeout)
+    {
+        auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
+        return withTimeout(microsecs.count());
+    }
+
     template <typename... _Args>
     inline AsyncMethodInvoker& AsyncMethodInvoker::withArguments(_Args&&... args)
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
         detail::serialize_pack(method_, std::forward<_Args>(args)...);
 
@@ -510,11 +576,11 @@ namespace sdbus {
     }
 
     template <typename _Function>
-    void AsyncMethodInvoker::uponReplyInvoke(_Function&& callback)
+    PendingAsyncCall AsyncMethodInvoker::uponReplyInvoke(_Function&& callback)
     {
-        SDBUS_THROW_ERROR_IF(!method_.isValid(), "DBus interface not specified when calling a DBus method", EINVAL);
+        assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
-        objectProxy_.callMethod(method_, [callback = std::forward<_Function>(callback)](MethodReply& reply, const Error* error)
+        auto asyncReplyHandler = [callback = std::forward<_Function>(callback)](MethodReply& reply, const Error* error)
         {
             // Create a tuple of callback input arguments' types, which will be used
             // as a storage for the argument values deserialized from the message.
@@ -525,20 +591,25 @@ namespace sdbus {
                 reply >> args;
 
             // 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);
+        };
+
+        return proxy_.callMethod(method_, std::move(asyncReplyHandler), timeout_);
     }
 
+    /*** ---------------- ***/
+    /*** SignalSubscriber ***/
+    /*** ---------------- ***/
 
-    inline SignalSubscriber::SignalSubscriber(IObjectProxy& objectProxy, const std::string& signalName)
-        : objectProxy_(objectProxy)
+    inline SignalSubscriber::SignalSubscriber(IProxy& proxy, const std::string& signalName)
+        : proxy_(proxy)
         , signalName_(signalName)
     {
     }
 
-    inline SignalSubscriber& SignalSubscriber::onInterface(const std::string& interfaceName)
+    inline SignalSubscriber& SignalSubscriber::onInterface(std::string interfaceName)
     {
-        interfaceName_ = interfaceName;
+        interfaceName_ = std::move(interfaceName);
 
         return *this;
     }
@@ -546,11 +617,11 @@ namespace sdbus {
     template <typename _Function>
     inline void SignalSubscriber::call(_Function&& callback)
     {
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when subscribing to a signal", EINVAL);
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
 
-        objectProxy_.registerSignalHandler( interfaceName_
-                                          , signalName_
-                                          , [callback = std::forward<_Function>(callback)](Signal& signal)
+        proxy_.registerSignalHandler( interfaceName_
+                                    , signalName_
+                                    , [callback = std::forward<_Function>(callback)](Signal& signal)
         {
             // Create a tuple of callback input arguments' types, which will be used
             // as a storage for the argument values deserialized from the signal message.
@@ -560,13 +631,16 @@ namespace sdbus {
             signal >> signalArgs;
 
             // Invoke callback with input arguments from the tuple.
-            sdbus::apply(callback, signalArgs); // We don't yet have C++17's std::apply :-(
+            sdbus::apply(callback, signalArgs);
         });
     }
 
+    /*** -------------- ***/
+    /*** PropertyGetter ***/
+    /*** -------------- ***/
 
-    inline PropertyGetter::PropertyGetter(IObjectProxy& objectProxy, const std::string& propertyName)
-        : objectProxy_(objectProxy)
+    inline PropertyGetter::PropertyGetter(IProxy& proxy, const std::string& propertyName)
+        : proxy_(proxy)
         , propertyName_(propertyName)
     {
     }
@@ -574,7 +648,7 @@ namespace sdbus {
     inline sdbus::Variant PropertyGetter::onInterface(const std::string& interfaceName)
     {
         sdbus::Variant var;
-        objectProxy_
+        proxy_
             .callMethod("Get")
             .onInterface("org.freedesktop.DBus.Properties")
             .withArguments(interfaceName, propertyName_)
@@ -582,16 +656,19 @@ namespace sdbus {
         return var;
     }
 
+    /*** -------------- ***/
+    /*** PropertySetter ***/
+    /*** -------------- ***/
 
-    inline PropertySetter::PropertySetter(IObjectProxy& objectProxy, const std::string& propertyName)
-        : objectProxy_(objectProxy)
+    inline PropertySetter::PropertySetter(IProxy& proxy, const std::string& propertyName)
+        : proxy_(proxy)
         , propertyName_(propertyName)
     {
     }
 
-    inline PropertySetter& PropertySetter::onInterface(const std::string& interfaceName)
+    inline PropertySetter& PropertySetter::onInterface(std::string interfaceName)
     {
-        interfaceName_ = interfaceName;
+        interfaceName_ = std::move(interfaceName);
 
         return *this;
     }
@@ -599,14 +676,19 @@ namespace sdbus {
     template <typename _Value>
     inline void PropertySetter::toValue(const _Value& value)
     {
-        SDBUS_THROW_ERROR_IF(interfaceName_.empty(), "DBus interface not specified when setting a property", EINVAL);
+        PropertySetter::toValue(sdbus::Variant{value});
+    }
 
-        objectProxy_
+    inline void PropertySetter::toValue(const sdbus::Variant& value)
+    {
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
+
+        proxy_
             .callMethod("Set")
             .onInterface("org.freedesktop.DBus.Properties")
-            .withArguments(interfaceName_, propertyName_, sdbus::Variant{value});
+            .withArguments(interfaceName_, propertyName_, value);
     }
 
 }
 
-#endif /* SDBUS_CPP_CONVENIENCECLASSES_INL_ */
+#endif /* SDBUS_CPP_CONVENIENCEAPICLASSES_INL_ */

include/sdbus-c++/Error.h

@@ -1,7 +1,8 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
- * @file ConvenienceClasses.h
+ * @file Error.h
  *
  * Created on: Nov 8, 2016
  * Project: sdbus-c++
@@ -26,7 +27,9 @@
 #ifndef SDBUS_CXX_ERROR_H_
 #define SDBUS_CXX_ERROR_H_
 
+#include <errno.h>
 #include <stdexcept>
+#include <string>
 
 namespace sdbus {
 

include/sdbus-c++/Flags.h

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

include/sdbus-c++/IConnection.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file IConnection.h
  *
@@ -26,9 +27,10 @@
 #ifndef SDBUS_CXX_ICONNECTION_H_
 #define SDBUS_CXX_ICONNECTION_H_
 
-//#include <cstdint>
 #include <string>
 #include <memory>
+#include <chrono>
+#include <cstdint>
 
 namespace sdbus {
 
@@ -36,122 +38,280 @@ 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. The class is
-     * thread-aware, but not thread-safe.
+     * All methods throw sdbus::Error in case of failure. All methods in
+     * this class are thread-aware, but not thread-safe.
      *
      ***********************************************/
     class IConnection
     {
     public:
+        struct PollData
+        {
+            int fd;
+            short int events;
+            uint64_t timeout_usec;
+        };
+
+        virtual ~IConnection() = default;
+
         /*!
-        * @brief Requests D-Bus name on the connection
-        *
-        * @param[in] name Name to request
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @brief Requests D-Bus name on the connection
+         *
+         * @param[in] name Name to request
+         *
+         * @throws sdbus::Error in case of failure
+         */
         virtual void requestName(const std::string& name) = 0;
 
         /*!
-        * @brief Releases D-Bus name on the connection
-        *
-        * @param[in] name Name to release
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @brief Releases D-Bus name on the connection
+         *
+         * @param[in] name Name to release
+         *
+         * @throws sdbus::Error in case of failure
+         */
         virtual void releaseName(const std::string& name) = 0;
 
         /*!
-        * @brief Enters the D-Bus processing loop
-        *
-        * The incoming D-Bus messages are processed in the loop. The method
-        * blocks indefinitely, until unblocked via @leaveProcessingLoop.
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual void enterProcessingLoop() = 0;
+         * @brief Retrieve the unique name of a connection. E.g. ":1.xx"
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual std::string getUniqueName() const = 0;
 
         /*!
-        * @brief Enters the D-Bus processing loop 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.
-        */
-        virtual void enterProcessingLoopAsync() = 0;
+         * @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 through leaveEventLoop().
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void enterEventLoop() = 0;
 
         /*!
-        * @brief Leaves the D-Bus processing loop
-        *
-        * Ends the previously started processing loop.
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual void leaveProcessingLoop() = 0;
+         * @brief Enters I/O event loop on this bus connection in a separate thread
+         *
+         * The same as enterEventLoop, except that it doesn't block
+         * because it runs the loop in a separate, internally managed thread.
+         */
+        virtual void enterEventLoopAsync() = 0;
 
-        inline virtual ~IConnection() = 0;
+        /*!
+         * @brief Leaves the I/O event loop running on this bus connection
+         *
+         * This causes the loop to exit and frees the thread serving the loop
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void leaveEventLoop() = 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.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void addObjectManager(const std::string& objectPath) = 0;
+
+        /*!
+         * @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
+         * method to query which file descriptors, poll events and timeouts you
+         * should add to your app's poll call in your main event loop. If these
+         * file descriptors signal, then you should call processPendingRequest
+         * 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
+         * 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 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 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.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual bool processPendingRequest() = 0;
+
+        /*!
+         * @brief Sets general method call timeout
+         *
+         * @param[in] timeout Timeout value in microseconds
+         *
+         * General method call timeout is used for all method calls upon this connection.
+         * Method call-specific timeout overrides this general setting.
+         *
+         * Supported by libsystemd>=v240.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void setMethodCallTimeout(uint64_t timeout) = 0;
+
+        /*!
+         * @copydoc IConnection::setMethodCallTimeout(uint64_t)
+         */
+        template <typename _Rep, typename _Period>
+        void setMethodCallTimeout(const std::chrono::duration<_Rep, _Period>& timeout);
+
+        /*!
+         * @brief Gets general method call timeout
+         *
+         * @return Timeout value in microseconds
+         *
+         * Supported by libsystemd>=v240.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual uint64_t getMethodCallTimeout() const = 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;
     };
 
-    IConnection::~IConnection() {}
+    template <typename _Rep, typename _Period>
+    inline void IConnection::setMethodCallTimeout(const std::chrono::duration<_Rep, _Period>& timeout)
+    {
+        auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
+        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
-    *
-    * @return Connection instance
-    *
-    * @throws sdbus::Error in case of failure
-    */
-    std::unique_ptr<sdbus::IConnection> createConnection();
+     * @brief Creates/opens D-Bus system connection
+     *
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection();
 
     /*!
-    * @brief Creates/opens D-Bus system 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);
+     * @brief Creates/opens D-Bus system 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> createConnection(const std::string& name);
 
     /*!
-    * @brief Creates/opens D-Bus system connection
-    *
-    * @return Connection instance
-    *
-    * @throws sdbus::Error in case of failure
-    */
-    std::unique_ptr<sdbus::IConnection> createSystemBusConnection();
+     * @brief Creates/opens D-Bus system connection
+     *
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSystemBusConnection();
 
     /*!
-    * @brief Creates/opens D-Bus system 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> createSystemBusConnection(const std::string& name);
+     * @brief Creates/opens D-Bus system 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> createSystemBusConnection(const std::string& name);
 
     /*!
-    * @brief Creates/opens D-Bus session connection
-    *
-    * @return Connection instance
-    *
-    * @throws sdbus::Error in case of failure
-    */
-    std::unique_ptr<sdbus::IConnection> createSessionBusConnection();
+     * @brief Creates/opens D-Bus session connection
+     *
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createSessionBusConnection();
 
     /*!
-    * @brief Creates/opens D-Bus session 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);
+     * @brief Creates/opens D-Bus session 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 system connection on a remote host using ssh
+     *
+     * @param[in] host Name of the host to connect
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host);
 }
 
 #endif /* SDBUS_CXX_ICONNECTION_H_ */

include/sdbus-c++/IObject.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file IObject.h
  *
@@ -26,12 +27,13 @@
 #ifndef SDBUS_CXX_IOBJECT_H_
 #define SDBUS_CXX_IOBJECT_H_
 
-#include <sdbus-c++/ConvenienceClasses.h>
+#include <sdbus-c++/ConvenienceApiClasses.h>
 #include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Flags.h>
 #include <functional>
 #include <string>
 #include <memory>
+#include <vector>
 
 // Forward declarations
 namespace sdbus {
@@ -44,252 +46,404 @@ namespace sdbus {
     /********************************************//**
      * @class IObject
      *
-     * An interface to D-Bus object. Provides API for registration
-     * of methods, signals, properties, and for emitting signals.
+     * IObject class represents a D-Bus object instance identified by a specific object path.
+     * D-Bus object provides its interfaces, methods, signals and properties on a bus
+     * identified by a specific bus name.
      *
-     * All methods throw @c sdbus::Error in case of failure. The class is
-     * thread-aware, but not thread-safe.
+     * All IObject member methods throw @c sdbus::Error in case of D-Bus or sdbus-c++ error.
+     * The IObject class has been designed as thread-aware. However, the operation of
+     * creating and sending asynchronous method replies, as well as creating and emitting
+     * signals, is thread-safe by design.
      *
      ***********************************************/
     class IObject
     {
     public:
+        virtual ~IObject() = default;
+
         /*!
-        * @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] outputSignature D-Bus signature of method output parameters
-        * @param[in] methodCallback Callback that implements the body of the method
-        * @param[in] noReply If true, the method isn't expected to send reply
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @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] outputSignature D-Bus signature of method 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)
+         *
+         * @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] outputSignature D-Bus signature of method output parameters
-        * @param[in] asyncMethodCallback Callback that implements the body of the method
-        * @param[in] noReply If true, the method isn't expected to send reply
-        *
-        * This overload register a method callback that will have a freedom to execute
-        * its body in asynchronous contexts, and send the results from those contexts.
-        * This can help in e.g. long operations, which then don't block the D-Bus processing
-        * loop thread.
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @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
-                                   , const std::string& methodName
-                                   , const std::string& inputSignature
-                                   , const std::string& outputSignature
-                                   , async_method_callback asyncMethodCallback
+                                   , 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;
 
         /*!
-        * @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
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @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] flags D-Bus signal flags (deprecated)
+         *
+         * @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 read-only property that the object will provide on D-Bus
-        *
-        * @param[in] interfaceName Name of an interface that the property will fall under
-        * @param[in] propertyName Name of the property
-        * @param[in] signature D-Bus signature of property parameters
-        * @param[in] getCallback Callback that implements the body of the property getter
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @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;
+
+        /*!
+         * @brief Registers read-only property that the object will provide on D-Bus
+         *
+         * @param[in] interfaceName Name of an interface that the property will fall under
+         * @param[in] propertyName Name of the property
+         * @param[in] signature D-Bus signature of property parameters
+         * @param[in] getCallback Callback that implements the body of the property getter
+         * @param[in] flags D-Bus property flags (deprecated, property update behavior)
+         *
+         * @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;
 
         /*!
-        * @brief Registers read/write property that the object will provide on D-Bus
-        *
-        * @param[in] interfaceName Name of an interface that the property will fall under
-        * @param[in] propertyName Name of the property
-        * @param[in] signature D-Bus signature of property parameters
-        * @param[in] getCallback Callback that implements the body of the property getter
-        * @param[in] setCallback Callback that implements the body of the property setter
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @brief Registers read/write property that the object will provide on D-Bus
+         *
+         * @param[in] interfaceName Name of an interface that the property will fall under
+         * @param[in] propertyName Name of the property
+         * @param[in] signature D-Bus signature of property parameters
+         * @param[in] getCallback Callback that implements the body of the property getter
+         * @param[in] setCallback Callback that implements the body of the property setter
+         * @param[in] flags D-Bus property flags (deprecated, property update behavior)
+         *
+         * @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;
 
         /*!
-        * @brief Sets flags for a given interface
-        *
-        * @param[in] interfaceName Name of an interface whose flags will be set
-        * @param[in] flags Flags to be set
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @brief Sets flags for a given interface
+         *
+         * @param[in] interfaceName Name of an interface whose flags will be set
+         * @param[in] flags Flags to be set
+         *
+         * @throws sdbus::Error in case of failure
+         */
         virtual void setInterfaceFlags(const std::string& interfaceName, Flags flags) = 0;
 
         /*!
-        * @brief Finishes the registration and exports object API on D-Bus
-        *
-        * The method exports all up to now registered methods, signals and properties on D-Bus.
-        * Must be called only once, after all methods, signals and properties have been registered.
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @brief Finishes object API registration and publishes the object on the bus
+         *
+         * The method exports all up to now registered methods, signals and properties on D-Bus.
+         * Must be called after all methods, signals and properties have been registered.
+         *
+         * @throws sdbus::Error in case of failure
+         */
         virtual void finishRegistration() = 0;
 
         /*!
-        * @brief Creates a signal message
-        *
-        * @param[in] interfaceName Name of an interface that the signal belongs under
-        * @param[in] signalName Name of the signal
-        * @return A signal message
-        *
-        * Serialize signal arguments into the returned message and emit the signal by passing
-        * the message with serialized arguments to the @c emitSignal function.
-        * Alternatively, use higher-level API @c emitSignal(const std::string& signalName) defined below.
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @brief Unregisters object's API and removes object from the bus
+         *
+         * This method unregisters the object, its interfaces, methods, signals and properties
+         * from the bus. Unregistration is done automatically also in object's destructor. This
+         * method makes sense if, in the process of object removal, we need to make sure that
+         * callbacks are unregistered explicitly before the final destruction of the object instance.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void unregister() = 0;
+
+        /*!
+         * @brief Creates a signal message
+         *
+         * @param[in] interfaceName Name of an interface that the signal belongs under
+         * @param[in] signalName Name of the signal
+         * @return A signal message
+         *
+         * Serialize signal arguments into the returned message and emit the signal by passing
+         * the message with serialized arguments to the @c emitSignal function.
+         * Alternatively, use higher-level API @c emitSignal(const std::string& signalName) defined below.
+         *
+         * @throws sdbus::Error in case of failure
+         */
         virtual Signal createSignal(const std::string& interfaceName, const std::string& signalName) = 0;
 
         /*!
-        * @brief Emits signal on D-Bus
-        *
-        * @param[in] message Signal message to be sent out
-        *
-        * Note: To avoid messing with messages, use higher-level API defined below.
-        *
-        * @throws sdbus::Error in case of failure
-        */
+         * @brief Emits signal for this object path
+         *
+         * @param[in] message Signal message to be sent out
+         *
+         * Note: To avoid messing with messages, use higher-level API defined below.
+         *
+         * @throws sdbus::Error in case of failure
+         */
         virtual void emitSignal(const sdbus::Signal& message) = 0;
 
         /*!
-        * @brief Registers method that the object will provide on D-Bus
-        *
-        * @param[in] methodName Name of the method
-        * @return A helper object for convenient registration of the method
-        *
-        * This is a high-level, convenience way of registering D-Bus methods that abstracts
-        * from the D-Bus message concept. Method arguments/return value are automatically (de)serialized
-        * in a message and D-Bus signatures automatically deduced from the parameters and return type
-        * of the provided native method implementation callback.
-        *
-        * Example of use:
-        * @code
-        * object.registerMethod("doFoo").onInterface("com.kistler.foo").implementedAs([this](int value){ return this->doFoo(value); });
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        MethodRegistrator registerMethod(const std::string& methodName);
+         * @brief Emits PropertyChanged signal for specified properties under a given interface of this object path
+         *
+         * @param[in] interfaceName Name of an interface that properties belong to
+         * @param[in] propNames Names of properties that will be included in the PropertiesChanged signal
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void emitPropertiesChangedSignal(const std::string& interfaceName, const std::vector<std::string>& propNames) = 0;
 
         /*!
-        * @brief Registers signal that the object will provide on D-Bus
-        *
-        * @param[in] signalName Name of the signal
-        * @return A helper object for convenient registration of the signal
-        *
-        * This is a high-level, convenience way of registering D-Bus signals that abstracts
-        * from the D-Bus message concept. Signal arguments are automatically (de)serialized
-        * in a message and D-Bus signatures automatically deduced from the provided native parameters.
-        *
-        * Example of use:
-        * @code
-        * object.registerSignal("paramChange").onInterface("com.kistler.foo").withParameters<std::map<int32_t, std::string>>();
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        SignalRegistrator registerSignal(const std::string& signalName);
+         * @brief Emits PropertyChanged signal for all properties on a given interface of this object path
+         *
+         * @param[in] interfaceName Name of an interface
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void emitPropertiesChangedSignal(const std::string& interfaceName) = 0;
 
         /*!
-        * @brief Registers property that the object will provide on D-Bus
-        *
-        * @param[in] propertyName Name of the property
-        * @return A helper object for convenient registration of the property
-        *
-        * This is a high-level, convenience way of registering D-Bus properties that abstracts
-        * from the D-Bus message concept. Property arguments are automatically (de)serialized
-        * in a message and D-Bus signatures automatically deduced from the provided native callbacks.
-        *
-        * Example of use:
-        * @code
-        * object_.registerProperty("state").onInterface("com.kistler.foo").withGetter([this](){ return this->state(); });
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        PropertyRegistrator registerProperty(const std::string& propertyName);
+         * @brief Emits InterfacesAdded signal on this object path
+         *
+         * This emits an InterfacesAdded signal on this object path, by iterating all registered
+         * interfaces on the path. All properties are queried and included in the signal.
+         * This call is equivalent to emitInterfacesAddedSignal() with an explicit list of
+         * registered interfaces. However, unlike emitInterfacesAddedSignal(interfaces), this
+         * call can figure out the list of supported interfaces itself. Furthermore, it properly
+         * adds the builtin org.freedesktop.DBus.* interfaces.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void emitInterfacesAddedSignal() = 0;
 
         /*!
-        * @brief Sets flags (annotations) for a given interface
-        *
-        * @param[in] interfaceName Name of an interface whose flags will be set
-        * @return A helper object for convenient setting of Interface flags
-        *
-        * This is a high-level, convenience alternative to the other setInterfaceFlags overload.
-        *
-        * Example of use:
-        * @code
-        * object_.setInterfaceFlags("com.kistler.foo").markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        InterfaceFlagsSetter setInterfaceFlags(const std::string& interfaceName);
+         * @brief Emits InterfacesAdded signal on this object path
+         *
+         * This emits an InterfacesAdded signal on this object path with explicitly provided list
+         * of registered interfaces. As sdbus-c++ does currently not supported adding/removing
+         * interfaces of an existing object at run time (an object has a fixed set of interfaces
+         * registered by the time of invoking finishRegistration()), emitInterfacesAddedSignal(void)
+         * is probably what you are looking for.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void emitInterfacesAddedSignal(const std::vector<std::string>& interfaces) = 0;
 
         /*!
-        * @brief Emits signal on D-Bus
-        *
-        * @param[in] signalName Name of the signal
-        * @return A helper object for convenient emission of signals
-        *
-        * This is a high-level, convenience way of emitting D-Bus signals that abstracts
-        * from the D-Bus message concept. Signal arguments are automatically serialized
-        * in a message and D-Bus signatures automatically deduced from the provided native arguments.
-        *
-        * Example of use:
-        * @code
-        * int arg1 = ...;
-        * double arg2 = ...;
-        * object_.emitSignal("fooSignal").onInterface("com.kistler.foo").withArguments(arg1, arg2);
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        SignalEmitter emitSignal(const std::string& signalName);
+         * @brief Emits InterfacesRemoved signal on this object path
+         *
+         * This is like sd_bus_emit_object_added(), but emits an InterfacesRemoved signal on this
+         * object path. This only includes any registered interfaces but skips the properties.
+         * This function shall be called (just) before destroying the object.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void emitInterfacesRemovedSignal() = 0;
 
-        virtual ~IObject() = 0;
+        /*!
+         * @brief Emits InterfacesRemoved signal on this object path
+         *
+         * This emits an InterfacesRemoved signal on the given path with explicitly provided list
+         * of registered interfaces. As sdbus-c++ does currently not supported adding/removing
+         * interfaces of an existing object at run time (an object has a fixed set of interfaces
+         * registered by the time of invoking finishRegistration()), emitInterfacesRemovedSignal(void)
+         * is probably what you are looking for.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void emitInterfacesRemovedSignal(const std::vector<std::string>& interfaces) = 0;
+
+        /*!
+         * @brief Adds an ObjectManager interface at the path of this D-Bus object
+         *
+         * 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.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void addObjectManager() = 0;
+
+        /*!
+         * @brief Removes an ObjectManager interface from the path of this D-Bus object
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void removeObjectManager() = 0;
+
+        /*!
+         * @brief Tests whether ObjectManager interface is added at the path of this D-Bus object
+         * @return True if ObjectManager interface is there, false otherwise
+         */
+        virtual bool hasObjectManager() const = 0;
+
+        /*!
+         * @brief Provides D-Bus connection used by the object
+         *
+         * @return Reference to the D-Bus connection
+         */
+        virtual sdbus::IConnection& getConnection() const = 0;
+
+        /*!
+         * @brief Registers method that the object will provide on D-Bus
+         *
+         * @param[in] methodName Name of the method
+         * @return A helper object for convenient registration of the method
+         *
+         * This is a high-level, convenience way of registering D-Bus methods that abstracts
+         * from the D-Bus message concept. Method arguments/return value are automatically (de)serialized
+         * in a message and D-Bus signatures automatically deduced from the parameters and return type
+         * of the provided native method implementation callback.
+         *
+         * Example of use:
+         * @code
+         * object.registerMethod("doFoo").onInterface("com.kistler.foo").implementedAs([this](int value){ return this->doFoo(value); });
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] MethodRegistrator registerMethod(const std::string& methodName);
+
+        /*!
+         * @brief Registers signal that the object will provide on D-Bus
+         *
+         * @param[in] signalName Name of the signal
+         * @return A helper object for convenient registration of the signal
+         *
+         * This is a high-level, convenience way of registering D-Bus signals that abstracts
+         * from the D-Bus message concept. Signal arguments are automatically (de)serialized
+         * in a message and D-Bus signatures automatically deduced from the provided native parameters.
+         *
+         * Example of use:
+         * @code
+         * object.registerSignal("paramChange").onInterface("com.kistler.foo").withParameters<std::map<int32_t, std::string>>();
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] SignalRegistrator registerSignal(const std::string& signalName);
+
+        /*!
+         * @brief Registers property that the object will provide on D-Bus
+         *
+         * @param[in] propertyName Name of the property
+         * @return A helper object for convenient registration of the property
+         *
+         * This is a high-level, convenience way of registering D-Bus properties that abstracts
+         * from the D-Bus message concept. Property arguments are automatically (de)serialized
+         * in a message and D-Bus signatures automatically deduced from the provided native callbacks.
+         *
+         * Example of use:
+         * @code
+         * object_.registerProperty("state").onInterface("com.kistler.foo").withGetter([this](){ return this->state(); });
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] PropertyRegistrator registerProperty(const std::string& propertyName);
+
+        /*!
+         * @brief Sets flags (annotations) for a given interface
+         *
+         * @param[in] interfaceName Name of an interface whose flags will be set
+         * @return A helper object for convenient setting of Interface flags
+         *
+         * This is a high-level, convenience alternative to the other setInterfaceFlags overload.
+         *
+         * Example of use:
+         * @code
+         * object_.setInterfaceFlags("com.kistler.foo").markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] InterfaceFlagsSetter setInterfaceFlags(const std::string& interfaceName);
+
+        /*!
+         * @brief Emits signal on D-Bus
+         *
+         * @param[in] signalName Name of the signal
+         * @return A helper object for convenient emission of signals
+         *
+         * This is a high-level, convenience way of emitting D-Bus signals that abstracts
+         * from the D-Bus message concept. Signal arguments are automatically serialized
+         * in a message and D-Bus signatures automatically deduced from the provided native arguments.
+         *
+         * Example of use:
+         * @code
+         * int arg1 = ...;
+         * double arg2 = ...;
+         * object_.emitSignal("fooSignal").onInterface("com.kistler.foo").withArguments(arg1, arg2);
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] SignalEmitter emitSignal(const std::string& signalName);
+
+        /*!
+         * @brief Returns object path of the underlying DBus object
+         */
+        virtual const std::string& getObjectPath() const = 0;
     };
 
+    // Out-of-line member definitions
+
     inline MethodRegistrator IObject::registerMethod(const std::string& methodName)
     {
         return MethodRegistrator(*this, methodName);
@@ -297,17 +451,17 @@ namespace sdbus {
 
     inline SignalRegistrator IObject::registerSignal(const std::string& signalName)
     {
-        return SignalRegistrator(*this, std::move(signalName));
+        return SignalRegistrator(*this, signalName);
     }
 
     inline PropertyRegistrator IObject::registerProperty(const std::string& propertyName)
     {
-        return PropertyRegistrator(*this, std::move(propertyName));
+        return PropertyRegistrator(*this, propertyName);
     }
 
     inline InterfaceFlagsSetter IObject::setInterfaceFlags(const std::string& interfaceName)
     {
-        return InterfaceFlagsSetter(*this, std::move(interfaceName));
+        return InterfaceFlagsSetter(*this, interfaceName);
     }
 
     inline SignalEmitter IObject::emitSignal(const std::string& signalName)
@@ -315,27 +469,28 @@ namespace sdbus {
         return SignalEmitter(*this, signalName);
     }
 
-    inline IObject::~IObject() {}
-
     /*!
-    * @brief Creates instance representing a D-Bus object
-    *
-    * @param[in] connection D-Bus connection to be used by the object
-    * @param[in] objectPath Path of the D-Bus object
-    * @return Pointer to the object representation instance
-    *
-    * The provided connection will be used by the object to export methods,
-    * issue signals and provide properties.
-    *
-    * Code example:
-    * @code
-    * auto proxy = sdbus::createObject(connection, "/com/kistler/foo");
-    * @endcode
-    */
-    std::unique_ptr<sdbus::IObject> createObject(sdbus::IConnection& connection, std::string objectPath);
+     * @brief Creates instance representing a D-Bus object
+     *
+     * @param[in] connection D-Bus connection to be used by the object
+     * @param[in] objectPath Path of the D-Bus object
+     * @return Pointer to the object representation instance
+     *
+     * The provided connection will be used by the object to export methods,
+     * issue signals and provide properties.
+     *
+     * Creating a D-Bus object instance is (thread-)safe even upon the connection
+     * which is already running its I/O event loop.
+     *
+     * Code example:
+     * @code
+     * auto proxy = sdbus::createObject(connection, "/com/kistler/foo");
+     * @endcode
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IObject> createObject(sdbus::IConnection& connection, std::string objectPath);
 
 }
 
-#include <sdbus-c++/ConvenienceClasses.inl>
+#include <sdbus-c++/ConvenienceApiClasses.inl>
 
 #endif /* SDBUS_CXX_IOBJECT_H_ */

include/sdbus-c++/IObjectProxy.h

@@ -1,350 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file IObjectProxy.h
- *
- * Created on: Nov 8, 2016
- * 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_IOBJECTPROXY_H_
-#define SDBUS_CXX_IOBJECTPROXY_H_
-
-#include <sdbus-c++/ConvenienceClasses.h>
-#include <string>
-#include <memory>
-#include <functional>
-
-// Forward declarations
-namespace sdbus {
-    class MethodCall;
-    class AsyncMethodCall;
-    class MethodReply;
-    class IConnection;
-}
-
-namespace sdbus {
-
-    /********************************************//**
-     * @class IObjectProxy
-     *
-     * An interface to D-Bus object proxy. Provides API for calling
-     * methods, getting/setting properties, and for registering to signals.
-     *
-     * All methods throw @c sdbus::Error in case of failure. The class is
-     * thread-aware, but not thread-safe.
-     *
-     ***********************************************/
-    class IObjectProxy
-    {
-    public:
-        /*!
-        * @brief Creates a method call message
-        *
-        * @param[in] interfaceName Name of an interface that the method is defined under
-        * @param[in] methodName Name of the method
-        * @return A method call message
-        *
-        * Serialize method arguments into the returned message and invoke the method by passing
-        * the message with serialized arguments to the @c callMethod function.
-        * Alternatively, use higher-level API @c callMethod(const std::string& methodName) defined below.
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;
-
-        /*!
-        * @brief Creates an asynchronous method call message
-        *
-        * @param[in] interfaceName Name of an interface that the method is defined under
-        * @param[in] methodName Name of the method
-        * @return A method call message
-        *
-        * Serialize method arguments into the returned message and invoke the method by passing
-        * the message with serialized arguments to the @c callMethod function.
-        * Alternatively, use higher-level API @c callMethodAsync(const std::string& methodName) defined below.
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual AsyncMethodCall createAsyncMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;
-
-        /*!
-        * @brief Calls method on the proxied D-Bus object
-        *
-        * @param[in] message Message representing a method call
-        * @return A method reply message
-        *
-        * Normally, the call is blocking, i.e. it waits for the remote method to finish with either
-        * a return value or an error.
-        *
-        * If the method call argument is set to not expect reply, the call will not wait for the remote
-        * method to finish, i.e. the call will be non-blocking, and the function will return an empty,
-        * invalid MethodReply object (representing void).
-        *
-        * Note: To avoid messing with messages, use higher-level API defined below.
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual MethodReply callMethod(const MethodCall& message) = 0;
-
-        /*!
-        * @brief Calls method on the proxied D-Bus object asynchronously
-        *
-        * @param[in] message Message representing an async method call
-        * @param[in] asyncReplyHandler Handler for the async reply
-        *
-        * 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.
-        *
-        * Note: To avoid messing with messages, use higher-level API defined below.
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual void callMethod(const AsyncMethodCall& message, async_reply_handler asyncReplyCallback) = 0;
-
-        /*!
-        * @brief Registers a handler for the desired signal emitted by the proxied D-Bus object
-        *
-        * @param[in] interfaceName Name of an interface that the signal belongs to
-        * @param[in] signalName Name of the signal
-        * @param[in] signalHandler Callback that implements the body of the signal handler
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual void registerSignalHandler( const std::string& interfaceName
-                                          , const std::string& signalName
-                                          , signal_handler signalHandler ) = 0;
-
-        /*!
-        * @brief Finishes the registration of signal handlers
-        *
-        * The method physically subscribes to the desired signals.
-        * Must be called only once, after all signals have been registered already.
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        virtual void finishRegistration() = 0;
-
-        /*!
-        * @brief Calls method on the proxied D-Bus object
-        *
-        * @param[in] methodName Name of the method
-        * @return A helper object for convenient invocation of the method
-        *
-        * This is a high-level, convenience way of calling D-Bus methods that abstracts
-        * from the D-Bus message concept. Method arguments/return value are automatically (de)serialized
-        * in a message and D-Bus signatures automatically deduced from the provided native arguments
-        * and return values.
-        *
-        * Example of use:
-        * @code
-        * int result, a = ..., b = ...;
-        * object_.callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        MethodInvoker callMethod(const std::string& methodName);
-
-        /*!
-        * @brief Calls method on the proxied D-Bus object asynchronously
-        *
-        * @param[in] methodName Name of the method
-        * @return A helper object for convenient asynchronous invocation of the method
-        *
-        * This is a high-level, convenience way of calling D-Bus methods that abstracts
-        * from the D-Bus message concept. Method arguments/return value are automatically (de)serialized
-        * in a message and D-Bus signatures automatically deduced from the provided native arguments
-        * and return values.
-        *
-        * Example of use:
-        * @code
-        * int a = ..., b = ...;
-        * object_.callMethodAsync("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).uponReplyInvoke([](int result)
-        * {
-        *     std::cout << "Got result of multiplying " << a << " and " << b << ": " << result << std::endl;
-        * });
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        AsyncMethodInvoker callMethodAsync(const std::string& methodName);
-
-        /*!
-        * @brief Registers signal handler for a given signal of the proxied D-Bus object
-        *
-        * @param[in] signalName Name of the signal
-        * @return A helper object for convenient registration of the signal handler
-        *
-        * This is a high-level, convenience way of registering to D-Bus signals that abstracts
-        * from the D-Bus message concept. Signal arguments are automatically serialized
-        * in a message and D-Bus signatures automatically deduced from the parameters
-        * of the provided native signal callback.
-        *
-        * Example of use:
-        * @code
-        * object_.uponSignal("fooSignal").onInterface("com.kistler.foo").call([this](int arg1, double arg2){ this->onFooSignal(arg1, arg2); });
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        SignalSubscriber uponSignal(const std::string& signalName);
-
-        /*!
-        * @brief Gets value of a property of the proxied D-Bus object
-        *
-        * @param[in] propertyName Name of the property
-        * @return A helper object for convenient getting of property value
-        *
-        * This is a high-level, convenience way of reading D-Bus property values that abstracts
-        * from the D-Bus message concept. sdbus::Variant is returned which shall then be converted
-        * to the real property type (implicit conversion is supported).
-        *
-        * Example of use:
-        * @code
-        * int state = object.getProperty("state").onInterface("com.kistler.foo");
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        PropertyGetter getProperty(const std::string& propertyName);
-
-        /*!
-        * @brief Sets value of a property of the proxied D-Bus object
-        *
-        * @param[in] propertyName Name of the property
-        * @return A helper object for convenient setting of property value
-        *
-        * This is a high-level, convenience way of writing D-Bus property values that abstracts
-        * from the D-Bus message concept.
-        *
-        * Example of use:
-        * @code
-        * int state = ...;
-        * object_.setProperty("state").onInterface("com.kistler.foo").toValue(state);
-        * @endcode
-        *
-        * @throws sdbus::Error in case of failure
-        */
-        PropertySetter setProperty(const std::string& propertyName);
-
-        virtual ~IObjectProxy() = 0;
-    };
-
-    inline MethodInvoker IObjectProxy::callMethod(const std::string& methodName)
-    {
-        return MethodInvoker(*this, methodName);
-    }
-
-    inline AsyncMethodInvoker IObjectProxy::callMethodAsync(const std::string& methodName)
-    {
-        return AsyncMethodInvoker(*this, methodName);
-    }
-
-    inline SignalSubscriber IObjectProxy::uponSignal(const std::string& signalName)
-    {
-        return SignalSubscriber(*this, signalName);
-    }
-
-    inline PropertyGetter IObjectProxy::getProperty(const std::string& propertyName)
-    {
-        return PropertyGetter(*this, propertyName);
-    }
-
-    inline PropertySetter IObjectProxy::setProperty(const std::string& propertyName)
-    {
-        return PropertySetter(*this, propertyName);
-    }
-
-    inline IObjectProxy::~IObjectProxy() {}
-
-    /*!
-    * @brief Creates object proxy instance
-    *
-    * @param[in] connection D-Bus connection to be used by the proxy object
-    * @param[in] destination Bus name that provides a D-Bus object
-    * @param[in] objectPath Path of the D-Bus object
-    * @return Pointer to the object proxy instance
-    *
-    * The provided connection will be used by the proxy to issue calls against the object,
-    * and signals, if any, will be subscribed to on this connection. Since the caller still
-    * remains the owner of the connection (the proxy just keeps reference to it) after the call,
-    * the proxy will not start its own background processing loop for incoming signals (if any),
-    * as it will rely on the client as an owner of the connection to handle processing of
-    * incoming messages on that connection by themselves.
-    *
-    * Code example:
-    * @code
-    * auto proxy = sdbus::createObjectProxy(connection, "com.kistler.foo", "/com/kistler/foo");
-    * @endcode
-    */
-    std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( sdbus::IConnection& connection
-                                                          , std::string destination
-                                                          , std::string objectPath );
-
-    /*!
-    * @brief Creates object proxy instance
-    *
-    * @param[in] connection D-Bus connection to be used by the proxy object
-    * @param[in] destination Bus name that provides a D-Bus object
-    * @param[in] objectPath Path of the D-Bus object
-    * @return Pointer to the object proxy instance
-    *
-    * The provided connection will be used by the proxy to issue calls against the object,
-    * and signals, if any, will be subscribed to on this connection. Object proxy becomes
-    * an exclusive owner of this connection. The effect of this is that when there is at
-    * least one signal in proxy's interface, then the proxy will immediately start its own
-    * processing loop for this connection in a separate internal thread, causing incoming
-    * signals to be correctly received and processed in the context of that internal thread.
-    *
-    * Code example:
-    * @code
-    * auto proxy = sdbus::createObjectProxy(std::move(connection), "com.kistler.foo", "/com/kistler/foo");
-    * @endcode
-    */
-    std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( std::unique_ptr<sdbus::IConnection>&& connection
-                                                          , std::string destination
-                                                          , std::string objectPath );
-
-    /*!
-    * @brief Creates object proxy instance that uses its own D-Bus connection
-    *
-    * @param[in] destination Bus name that provides a D-Bus object
-    * @param[in] objectPath Path of the D-Bus object
-    * @return Pointer to the object proxy instance
-    *
-    * This factory overload creates a proxy that manages its own D-Bus connection(s).
-    * When there is at least one signal in proxy's interface, then the proxy will immediately
-    * start its own processing loop for this connection in its own separate thread, causing
-    * incoming signals to be correctly received and processed in the context of that thread.
-    *
-    * Code example:
-    * @code
-    * auto proxy = sdbus::createObjectProxy(connection, "com.kistler.foo", "/com/kistler/foo");
-    * @endcode
-    */
-    std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( std::string destination
-                                                          , std::string objectPath );
-
-}
-
-#include <sdbus-c++/ConvenienceClasses.inl>
-
-#endif /* SDBUS_CXX_IOBJECTPROXY_H_ */

include/sdbus-c++/IProxy.h

@@ -0,0 +1,427 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file IProxy.h
+ *
+ * Created on: Nov 8, 2016
+ * 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_IPROXY_H_
+#define SDBUS_CXX_IPROXY_H_
+
+#include <sdbus-c++/ConvenienceApiClasses.h>
+#include <string>
+#include <memory>
+#include <functional>
+#include <chrono>
+
+// Forward declarations
+namespace sdbus {
+    class MethodCall;
+    class MethodReply;
+    class IConnection;
+    class PendingAsyncCall;
+    namespace internal {
+        class Proxy;
+    }
+}
+
+namespace sdbus {
+
+    /********************************************//**
+     * @class IProxy
+     *
+     * IProxy class represents a proxy object, which is a convenient local object created
+     * to represent a remote D-Bus object in another process.
+     * The proxy enables calling methods on remote objects, receiving signals from remote
+     * objects, and getting/setting properties of remote objects.
+     *
+     * All IProxy member methods throw @c sdbus::Error in case of D-Bus or sdbus-c++ error.
+     * The IProxy class has been designed as thread-aware. However, the operation of
+     * creating and sending method calls (both synchronously and asynchronously) is
+     * thread-safe by design.
+     *
+     ***********************************************/
+    class IProxy
+    {
+    public:
+        virtual ~IProxy() = default;
+
+        /*!
+         * @brief Creates a method call message
+         *
+         * @param[in] interfaceName Name of an interface that provides a given method
+         * @param[in] methodName Name of the method
+         * @return A method call message
+         *
+         * Serialize method arguments into the returned message and invoke the method by passing
+         * the message with serialized arguments to the @c callMethod function.
+         * Alternatively, use higher-level API @c callMethod(const std::string& methodName) defined below.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;
+
+        /*!
+         * @brief Calls method on the proxied D-Bus object
+         *
+         * @param[in] message Message representing a method call
+         * @param[in] timeout Timeout for dbus call in microseconds
+         * @return A method reply message
+         *
+         * Normally, the call is blocking, i.e. it waits for the remote method to finish with either
+         * a return value or an error.
+         *
+         * If the method call argument is set to not expect reply, the call will not wait for the remote
+         * method to finish, i.e. the call will be non-blocking, and the function will return an empty,
+         * invalid MethodReply object (representing void).
+         *
+         * Note: To avoid messing with messages, use higher-level API defined below.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual MethodReply callMethod(const MethodCall& message, uint64_t timeout = 0) = 0;
+
+        /*!
+         * @copydoc IProxy::callMethod(const MethodCall&,uint64_t)
+         */
+        template <typename _Rep, typename _Period>
+        MethodReply callMethod(const MethodCall& message, const std::chrono::duration<_Rep, _Period>& timeout);
+
+        /*!
+         * @brief Calls method on the proxied D-Bus object asynchronously
+         *
+         * @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
+         * 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 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>
+        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
+         *
+         * @param[in] interfaceName Name of an interface that the signal belongs to
+         * @param[in] signalName Name of the signal
+         * @param[in] signalHandler Callback that implements the body of the signal handler
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void registerSignalHandler( const std::string& interfaceName
+                                          , const std::string& signalName
+                                          , signal_handler signalHandler ) = 0;
+
+        /*!
+         * @brief Finishes the registration of signal handlers
+         *
+         * The method physically subscribes to the desired signals.
+         * Must be called only once, after all signals have been registered already.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void finishRegistration() = 0;
+
+        /*!
+         * @brief Unregisters proxy's signal handlers and stops receving replies to pending async calls
+         *
+         * Unregistration is done automatically also in proxy's destructor. This method makes
+         * sense if, in the process of proxy removal, we need to make sure that callbacks
+         * are unregistered explicitly before the final destruction of the proxy instance.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void unregister() = 0;
+
+        /*!
+         * @brief Calls method on the proxied D-Bus object
+         *
+         * @param[in] methodName Name of the method
+         * @return A helper object for convenient invocation of the method
+         *
+         * This is a high-level, convenience way of calling D-Bus methods that abstracts
+         * from the D-Bus message concept. Method arguments/return value are automatically (de)serialized
+         * in a message and D-Bus signatures automatically deduced from the provided native arguments
+         * and return values.
+         *
+         * Example of use:
+         * @code
+         * int result, a = ..., b = ...;
+         * object_.callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] MethodInvoker callMethod(const std::string& methodName);
+
+        /*!
+         * @brief Calls method on the proxied D-Bus object asynchronously
+         *
+         * @param[in] methodName Name of the method
+         * @return A helper object for convenient asynchronous invocation of the method
+         *
+         * This is a high-level, convenience way of calling D-Bus methods that abstracts
+         * from the D-Bus message concept. Method arguments/return value are automatically (de)serialized
+         * in a message and D-Bus signatures automatically deduced from the provided native arguments
+         * and return values.
+         *
+         * Example of use:
+         * @code
+         * int a = ..., b = ...;
+         * object_.callMethodAsync("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).uponReplyInvoke([](int result)
+         * {
+         *     std::cout << "Got result of multiplying " << a << " and " << b << ": " << result << std::endl;
+         * });
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] AsyncMethodInvoker callMethodAsync(const std::string& methodName);
+
+        /*!
+         * @brief Registers signal handler for a given signal of the proxied D-Bus object
+         *
+         * @param[in] signalName Name of the signal
+         * @return A helper object for convenient registration of the signal handler
+         *
+         * This is a high-level, convenience way of registering to D-Bus signals that abstracts
+         * from the D-Bus message concept. Signal arguments are automatically serialized
+         * in a message and D-Bus signatures automatically deduced from the parameters
+         * of the provided native signal callback.
+         *
+         * Example of use:
+         * @code
+         * object_.uponSignal("fooSignal").onInterface("com.kistler.foo").call([this](int arg1, double arg2){ this->onFooSignal(arg1, arg2); });
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] SignalSubscriber uponSignal(const std::string& signalName);
+
+        /*!
+         * @brief Gets value of a property of the proxied D-Bus object
+         *
+         * @param[in] propertyName Name of the property
+         * @return A helper object for convenient getting of property value
+         *
+         * This is a high-level, convenience way of reading D-Bus property values that abstracts
+         * from the D-Bus message concept. sdbus::Variant is returned which shall then be converted
+         * to the real property type (implicit conversion is supported).
+         *
+         * Example of use:
+         * @code
+         * int state = object.getProperty("state").onInterface("com.kistler.foo");
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] PropertyGetter getProperty(const std::string& propertyName);
+
+        /*!
+         * @brief Sets value of a property of the proxied D-Bus object
+         *
+         * @param[in] propertyName Name of the property
+         * @return A helper object for convenient setting of property value
+         *
+         * This is a high-level, convenience way of writing D-Bus property values that abstracts
+         * from the D-Bus message concept.
+         *
+         * Example of use:
+         * @code
+         * int state = ...;
+         * object_.setProperty("state").onInterface("com.kistler.foo").toValue(state);
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] PropertySetter setProperty(const std::string& propertyName);
+
+        /*!
+         * @brief Returns object path of the underlying DBus object
+         */
+        virtual const std::string& getObjectPath() 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:
+        /*!
+         * @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
+
+    template <typename _Rep, typename _Period>
+    inline MethodReply IProxy::callMethod(const MethodCall& message, const std::chrono::duration<_Rep, _Period>& timeout)
+    {
+        auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
+        return callMethod(message, microsecs.count());
+    }
+
+    template <typename _Rep, typename _Period>
+    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);
+        return callMethod(message, std::move(asyncReplyCallback), microsecs.count());
+    }
+
+    inline MethodInvoker IProxy::callMethod(const std::string& methodName)
+    {
+        return MethodInvoker(*this, methodName);
+    }
+
+    inline AsyncMethodInvoker IProxy::callMethodAsync(const std::string& methodName)
+    {
+        return AsyncMethodInvoker(*this, methodName);
+    }
+
+    inline SignalSubscriber IProxy::uponSignal(const std::string& signalName)
+    {
+        return SignalSubscriber(*this, signalName);
+    }
+
+    inline PropertyGetter IProxy::getProperty(const std::string& propertyName)
+    {
+        return PropertyGetter(*this, propertyName);
+    }
+
+    inline PropertySetter IProxy::setProperty(const std::string& propertyName)
+    {
+        return PropertySetter(*this, propertyName);
+    }
+
+    /*!
+     * @brief Creates a proxy object for a specific remote D-Bus object
+     *
+     * @param[in] connection D-Bus connection to be used by the proxy object
+     * @param[in] destination Bus name that provides the remote D-Bus object
+     * @param[in] objectPath Path of the remote D-Bus object
+     * @return Pointer to the proxy object instance
+     *
+     * The provided connection will be used by the proxy to issue calls against the object,
+     * and signals, if any, will be subscribed to on this connection. The caller still
+     * remains the owner of the connection (the proxy just keeps a reference to it), and
+     * 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:
+     * @code
+     * auto proxy = sdbus::createProxy(connection, "com.kistler.foo", "/com/kistler/foo");
+     * @endcode
+     */
+    [[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
+     *
+     * @param[in] connection D-Bus connection to be used by the proxy object
+     * @param[in] destination Bus name that provides the remote D-Bus object
+     * @param[in] objectPath Path of the remote D-Bus object
+     * @return Pointer to the object proxy instance
+     *
+     * The provided connection will be used by the proxy to issue calls against the object,
+     * and signals, if any, will be subscribed to on this connection. The Object proxy becomes
+     * an exclusive owner of this connection, and will automatically start a procesing loop
+     * upon that connection in a separate internal thread. Handlers for incoming signals and
+     * asynchronous method replies will be executed in the context of that thread.
+     *
+     * Code example:
+     * @code
+     * auto proxy = sdbus::createProxy(std::move(connection), "com.kistler.foo", "/com/kistler/foo");
+     * @endcode
+     */
+    [[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
+     *
+     * @param[in] destination Bus name that provides the remote D-Bus object
+     * @param[in] objectPath Path of the remote D-Bus object
+     * @return Pointer to the object proxy instance
+     *
+     * No D-Bus connection is provided here, so the object proxy will create and manage
+     * his own connection, and will automatically start a procesing loop upon that connection
+     * in a separate internal thread. Handlers for incoming signals and asynchronous
+     * method replies will be executed in the context of that thread.
+     *
+     * Code example:
+     * @code
+     * auto proxy = sdbus::createProxy("com.kistler.foo", "/com/kistler/foo");
+     * @endcode
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
+                                                            , std::string objectPath );
+
+}
+
+#include <sdbus-c++/ConvenienceApiClasses.inl>
+
+#endif /* SDBUS_CXX_IPROXY_H_ */

include/sdbus-c++/Interfaces.h

@@ -1,156 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file Interfaces.h
- *
- * Created on: Nov 8, 2016
- * 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_INTERFACES_H_
-#define SDBUS_CXX_INTERFACES_H_
-
-#include <sdbus-c++/IObject.h>
-#include <sdbus-c++/IObjectProxy.h>
-#include <cassert>
-#include <string>
-#include <memory>
-
-// Forward declarations
-namespace sdbus {
-    class IConnection;
-}
-
-namespace sdbus {
-
-    template <typename _Object>
-    class ObjectHolder
-    {
-    protected:
-        ObjectHolder(std::unique_ptr<_Object>&& object)
-            : object_(std::move(object))
-        {
-        }
-
-        const _Object& getObject() const
-        {
-            assert(object_ != nullptr);
-            return *object_;
-        }
-
-        _Object& getObject()
-        {
-            assert(object_ != nullptr);
-            return *object_;
-        }
-
-    private:
-        std::unique_ptr<_Object> object_;
-    };
-
-    /********************************************//**
-     * @class Interfaces
-     *
-     * A helper template class that a user class representing a D-Bus object
-     * should inherit from, providing as template arguments the adaptor
-     * classes representing D-Bus interfaces that the object implements.
-     *
-     ***********************************************/
-    template <typename... _Interfaces>
-    class Interfaces
-        : private ObjectHolder<IObject>
-        , public _Interfaces...
-    {
-    public:
-        Interfaces(IConnection& connection, std::string objectPath)
-            : ObjectHolder<IObject>(createObject(connection, std::move(objectPath)))
-            , _Interfaces(getObject())...
-        {
-            getObject().finishRegistration();
-        }
-    };
-
-    /********************************************//**
-     * @class Interfaces
-     *
-     * A helper template class that a user class representing a proxy of a
-     * D-Bus object should inherit from, providing as template arguments the proxy
-     * classes representing object D-Bus interfaces that the object implements.
-     *
-     ***********************************************/
-    template <typename... _Interfaces>
-    class ProxyInterfaces
-        : private ObjectHolder<IObjectProxy>
-        , public _Interfaces...
-    {
-    public:
-        /*!
-        * @brief Creates fully working object proxy instance
-        *
-        * @param[in] destination Bus name that provides a D-Bus object
-        * @param[in] objectPath Path of the D-Bus object
-        *
-        * This constructor overload creates a proxy that manages its own D-Bus connection(s).
-        * For more information on its behavior, consult @ref createObjectProxy(std::string, std::string)
-        */
-        ProxyInterfaces(std::string destination, std::string objectPath)
-            : ObjectHolder<IObjectProxy>(createObjectProxy(std::move(destination), std::move(objectPath)))
-            , _Interfaces(getObject())...
-        {
-            getObject().finishRegistration();
-        }
-
-        /*!
-        * @brief Creates fully working object proxy instance
-        *
-        * @param[in] connection D-Bus connection to be used by the proxy object
-        * @param[in] destination Bus name that provides a D-Bus object
-        * @param[in] objectPath Path of the D-Bus object
-        *
-        * The proxy created this way just references a D-Bus connection owned and managed by the user.
-        * For more information on its behavior, consult @ref createObjectProxy(IConnection&,std::string, std::string)
-        */
-        ProxyInterfaces(IConnection& connection, std::string destination, std::string objectPath)
-            : ObjectHolder<IObjectProxy>(createObjectProxy(connection, std::move(destination), std::move(objectPath)))
-            , _Interfaces(getObject())...
-        {
-            getObject().finishRegistration();
-        }
-
-        /*!
-        * @brief Creates fully working object proxy instance
-        *
-        * @param[in] connection D-Bus connection to be used by the proxy object
-        * @param[in] destination Bus name that provides a D-Bus object
-        * @param[in] objectPath Path of the D-Bus object
-        *
-        * The proxy created this way becomes an owner of the connection.
-        * For more information on its behavior, consult @ref createObjectProxy(std::unique_ptr<sdbus::IConnection>&&,std::string, std::string)
-        */
-        ProxyInterfaces(std::unique_ptr<sdbus::IConnection>&& connection, std::string destination, std::string objectPath)
-            : ObjectHolder<IObjectProxy>(createObjectProxy(std::move(connection), std::move(destination), std::move(objectPath)))
-            , _Interfaces(getObject())...
-        {
-            getObject().finishRegistration();
-        }
-    };
-
-}
-
-#endif /* SDBUS_CXX_INTERFACES_H_ */

include/sdbus-c++/Introspection.h

@@ -1,84 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file Introspection.h
- *
- * Created on: Dec 13, 2016
- * 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_INTROSPECTION_H_
-#define SDBUS_CXX_INTROSPECTION_H_
-
-#include <sdbus-c++/IObject.h>
-#include <sdbus-c++/IObjectProxy.h>
-#include <string>
-
-namespace sdbus {
-
-    // Proxy for introspection
-    class introspectable_proxy
-    {
-        static constexpr const char* interfaceName = "org.freedesktop.DBus.Introspectable";
-
-    protected:
-        introspectable_proxy(sdbus::IObjectProxy& object)
-            : object_(object)
-        {
-        }
-
-    public:
-        std::string Introspect()
-        {
-            std::string xml;
-            object_.callMethod("Introspect").onInterface(interfaceName).storeResultsTo(xml);
-            return xml;
-        }
-
-    private:
-        sdbus::IObjectProxy& object_;
-    };
-
-    // Adaptor is not necessary if we want to rely on sdbus-provided introspection
-//    class introspectable_adaptor
-//    {
-//        static constexpr const char* interfaceName = "org.freedesktop.DBus.Introspectable";
-//
-//    protected:
-//        introspectable_adaptor(sdbus::IObject& object)
-//            : object_(object)
-//        {
-//            object_.registerMethod("Introspect").onInterface(interfaceName).implementedAs([this](){ return object_.introspect(); });
-//        }
-//
-//    public:
-//        std::string introspect()
-//        {
-//            std::string xml;
-//            object_.callMethod("Introspect").onInterface(interfaceName).storeResultsTo(xml);
-//            return xml;
-//        }
-//
-//    private:
-//        sdbus::IObject& object_;
-//    };
-
-}
-
-#endif /* SDBUS_CXX_INTROSPECTION_H_ */

include/sdbus-c++/Message.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Message.h
  *
@@ -35,8 +36,7 @@
 #include <utility>
 #include <cstdint>
 #include <cassert>
-
-#include <iostream>
+#include <functional>
 
 // Forward declarations
 namespace sdbus {
@@ -44,6 +44,7 @@ namespace sdbus {
     class ObjectPath;
     class Signature;
     template <typename... _ValueTypes> class Struct;
+    struct UnixFd;
     class MethodReply;
     namespace internal {
         class ISdBus;
@@ -54,11 +55,7 @@ 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
@@ -71,22 +68,12 @@ namespace sdbus {
      * by D-Bus.
      *
      * You don't need to work with this class directly if you use high-level APIs
-     * of @c IObject and @c IObjectProxy.
+     * of @c IObject and @c IProxy.
      *
      ***********************************************/
-    class Message
+    class [[nodiscard]] Message
     {
     public:
-        Message() = default;
-        Message(internal::ISdBus* sdbus) noexcept;
-        Message(void *msg, internal::ISdBus* sdbus) noexcept;
-        Message(void *msg, internal::ISdBus* sdbus, adopt_message_t) noexcept;
-        Message(const Message&) noexcept;
-        Message& operator=(const Message&) noexcept;
-        Message(Message&& other) noexcept;
-        Message& operator=(Message&& other) noexcept;
-        ~Message();
-
         Message& operator<<(bool item);
         Message& operator<<(int16_t item);
         Message& operator<<(int32_t item);
@@ -101,6 +88,7 @@ namespace sdbus {
         Message& operator<<(const Variant &item);
         Message& operator<<(const ObjectPath &item);
         Message& operator<<(const Signature &item);
+        Message& operator<<(const UnixFd &item);
 
         Message& operator>>(bool& item);
         Message& operator>>(int16_t& item);
@@ -116,6 +104,7 @@ namespace sdbus {
         Message& operator>>(Variant &item);
         Message& operator>>(ObjectPath &item);
         Message& operator>>(Signature &item);
+        Message& operator>>(UnixFd &item);
 
         Message& openContainer(const std::string& signature);
         Message& closeContainer();
@@ -135,11 +124,12 @@ namespace sdbus {
         Message& enterStruct(const std::string& signature);
         Message& exitStruct();
 
-        operator bool() const;
+        explicit operator bool() const;
         void clearFlags();
 
         std::string getInterfaceName() const;
         std::string getMemberName() const;
+        std::string getSender() const;
         void peekType(std::string& type, std::string& contents) const;
         bool isValid() const;
         bool isEmpty() const;
@@ -148,50 +138,104 @@ namespace sdbus {
         void seal();
         void rewind(bool complete);
 
+        class Factory;
+
+    protected:
+        Message() = default;
+        explicit Message(internal::ISdBus* sdbus) noexcept;
+        Message(void *msg, internal::ISdBus* sdbus) noexcept;
+        Message(void *msg, internal::ISdBus* sdbus, adopt_message_t) noexcept;
+
+        Message(const Message&) noexcept;
+        Message& operator=(const Message&) noexcept;
+        Message(Message&& other) noexcept;
+        Message& operator=(Message&& other) noexcept;
+
+        ~Message();
+
+        friend Factory;
+
     protected:
         void* msg_{};
         internal::ISdBus* 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
     {
-    public:
         using Message::Message;
-        MethodReply send() const;
+        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;
+        [[nodiscard]] Slot send(void* callback, void* userData, uint64_t timeout) const;
+
         MethodReply createReply() const;
         MethodReply createErrorReply(const sdbus::Error& error) const;
+
         void dontExpectReply();
         bool doesntExpectReply() const;
 
     private:
-        MethodReply sendWithReply() const;
+        MethodReply sendWithReply(uint64_t timeout = 0) const;
         MethodReply sendWithNoReply() const;
     };
 
-    class AsyncMethodCall : public Message
-    {
-    public:
-        using Message::Message;
-        AsyncMethodCall() = default; // Fixes gcc 6.3 error (default c-tor is not imported in above using declaration)
-        AsyncMethodCall(MethodCall&& call) noexcept;
-        void send(void* callback, void* userData) const;
-    };
-
     class MethodReply : public Message
     {
-    public:
         using Message::Message;
+        friend Factory;
+
+    public:
+        MethodReply() = default;
         void send() const;
     };
 
     class Signal : public Message
     {
-    public:
         using Message::Message;
+        friend Factory;
+
+    public:
+        Signal() = default;
         void send() const;
     };
 
+    class PropertySetCall : public Message
+    {
+        using Message::Message;
+        friend Factory;
+
+    public:
+        PropertySetCall() = default;
+    };
+
+    class PropertyGetReply : public Message
+    {
+        using Message::Message;
+        friend Factory;
+
+    public:
+        PropertyGetReply() = default;
+    };
+
+    class PlainMessage : public Message
+    {
+        using Message::Message;
+        friend Factory;
+
+    public:
+        PlainMessage() = default;
+    };
+
     template <typename _Element>
     inline Message& operator<<(Message& msg, const std::vector<_Element>& items)
     {
@@ -231,10 +275,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>
@@ -326,10 +367,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,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file MethodResult.h
  *
@@ -31,43 +32,11 @@
 
 // Forward declaration
 namespace sdbus {
-    namespace internal {
-        class Object;
-    }
     class Error;
 }
 
 namespace sdbus {
 
-    /********************************************//**
-     * @class MethodResult
-     *
-     * Represents result of an asynchronous server-side method.
-     * An instance is provided to the method and shall be set
-     * by the method to either method return value or an error.
-     *
-     ***********************************************/
-    class MethodResult
-    {
-    protected:
-        friend sdbus::internal::Object;
-
-        MethodResult() = default;
-        MethodResult(MethodCall msg);
-
-        MethodResult(const MethodResult&) = delete;
-        MethodResult& operator=(const MethodResult&) = delete;
-
-        MethodResult(MethodResult&& other) = default;
-        MethodResult& operator=(MethodResult&& other) = default;
-
-        template <typename... _Results> void returnResults(const _Results&... results) const;
-        void returnError(const Error& error) const;
-
-    private:
-        MethodCall call_;
-    };
-
     /********************************************//**
      * @class Result
      *
@@ -77,18 +46,47 @@ namespace sdbus {
      *
      ***********************************************/
     template <typename... _Results>
-    class Result : protected MethodResult
+    class Result
     {
     public:
         Result() = default;
-        Result(MethodResult&& result);
+        Result(MethodCall call);
+
+        Result(const Result&) = delete;
+        Result& operator=(const Result&) = delete;
+
+        Result(Result&& other) = default;
+        Result& operator=(Result&& other) = default;
 
         void returnResults(const _Results&... results) const;
         void returnError(const Error& error) const;
+
+    private:
+        MethodCall call_;
     };
 
+    template <typename... _Results>
+    inline Result<_Results...>::Result(MethodCall call)
+        : call_(std::move(call))
+    {
+    }
+
+    template <typename... _Results>
+    inline void Result<_Results...>::returnResults(const _Results&... results) const
+    {
+        assert(call_.isValid());
+        auto reply = call_.createReply();
+        (reply << ... << results);
+        reply.send();
+    }
+
+    template <typename... _Results>
+    inline void Result<_Results...>::returnError(const Error& error) const
+    {
+        auto reply = call_.createErrorReply(error);
+        reply.send();
+    }
+
 }
 
-#include <sdbus-c++/MethodResult.inl>
-
 #endif /* SDBUS_CXX_METHODRESULT_H_ */

include/sdbus-c++/MethodResult.inl

@@ -1,79 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file MethodResult.inl
- *
- * Created on: Mar 21, 2019
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef SDBUS_CXX_METHODRESULT_INL_
-#define SDBUS_CXX_METHODRESULT_INL_
-
-#include <sdbus-c++/MethodResult.h>
-#include <cassert>
-
-namespace sdbus {
-
-    inline MethodResult::MethodResult(MethodCall msg)
-        : call_(std::move(msg))
-    {
-    }
-
-    template <typename... _Results>
-    inline void MethodResult::returnResults(const _Results&... results) const
-    {
-        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();
-    }
-
-    inline void MethodResult::returnError(const Error& error) const
-    {
-        auto reply = call_.createErrorReply(error);
-        reply.send();
-    }
-
-    template <typename... _Results>
-    inline Result<_Results...>::Result(MethodResult&& result)
-        : MethodResult(std::move(result))
-    {
-    }
-
-    template <typename... _Results>
-    inline void Result<_Results...>::returnResults(const _Results&... results) const
-    {
-        MethodResult::returnResults(results...);
-    }
-
-    template <typename... _Results>
-    inline void Result<_Results...>::returnError(const Error& error) const
-    {
-        MethodResult::returnError(error);
-    }
-
-}
-
-#endif /* SDBUS_CXX_METHODRESULT_INL_ */

include/sdbus-c++/ProxyInterfaces.h

@@ -0,0 +1,182 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file ProxyInterfaces.h
+ *
+ * Created on: Apr 8, 2019
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef SDBUS_CXX_PROXYINTERFACES_H_
+#define SDBUS_CXX_PROXYINTERFACES_H_
+
+#include <sdbus-c++/IProxy.h>
+#include <cassert>
+#include <string>
+#include <memory>
+
+// Forward declarations
+namespace sdbus {
+    class IConnection;
+}
+
+namespace sdbus {
+
+    /********************************************//**
+     * @class ProxyObjectHolder
+     *
+     * ProxyObjectHolder is a helper that simply owns and provides
+     * access to a proxy object to other classes in the inheritance
+     * hierarchy of a native-like proxy object based on generated
+     * interface classes.
+     *
+     ***********************************************/
+    class ProxyObjectHolder
+    {
+    protected:
+        ProxyObjectHolder(std::unique_ptr<IProxy>&& proxy)
+            : proxy_(std::move(proxy))
+        {
+            assert(proxy_ != nullptr);
+        }
+
+        const IProxy& getProxy() const
+        {
+            assert(proxy_ != nullptr);
+            return *proxy_;
+        }
+
+        IProxy& getProxy()
+        {
+            assert(proxy_ != nullptr);
+            return *proxy_;
+        }
+
+    private:
+        std::unique_ptr<IProxy> proxy_;
+    };
+
+    /********************************************//**
+     * @class ProxyInterfaces
+     *
+     * ProxyInterfaces is a helper template class that joins all interface classes of a remote
+     * D-Bus object generated by sdbus-c++-xml2cpp to be used on the client (the proxy) side,
+     * including some auxiliary classes. ProxyInterfaces is the class that native-like proxy
+     * implementation classes written by users should inherit from and implement all pure virtual
+     * methods. So the _Interfaces template parameter is a list of sdbus-c++-xml2cpp-generated
+     * proxy-side interface classes representing interfaces of the corresponding remote D-Bus object.
+     *
+     * In the final proxy class inherited from ProxyInterfaces, it is necessary to finish proxy
+     * registration in class constructor (`finishRegistration();`), and, conversely, unregister
+     * the proxy in class destructor (`unregister();`).
+     *
+     ***********************************************/
+    template <typename... _Interfaces>
+    class ProxyInterfaces
+        : protected ProxyObjectHolder
+        , public _Interfaces...
+    {
+    public:
+        /*!
+         * @brief Creates native-like proxy object instance
+         *
+         * @param[in] destination Bus name that provides a D-Bus object
+         * @param[in] objectPath Path of the D-Bus object
+         *
+         * This constructor overload creates a proxy that manages its own D-Bus connection(s).
+         * For more information on its behavior, consult @ref createProxy(std::string,std::string)
+         */
+        ProxyInterfaces(std::string destination, std::string objectPath)
+            : ProxyObjectHolder(createProxy(std::move(destination), std::move(objectPath)))
+            , _Interfaces(getProxy())...
+        {
+        }
+
+        /*!
+         * @brief Creates native-like proxy object instance
+         *
+         * @param[in] connection D-Bus connection to be used by the proxy object
+         * @param[in] destination Bus name that provides a D-Bus object
+         * @param[in] objectPath Path of the D-Bus object
+         *
+         * The proxy created this way just references a D-Bus connection owned and managed by the user.
+         * For more information on its behavior, consult @ref createProxy(IConnection&,std::string,std::string)
+         */
+        ProxyInterfaces(IConnection& connection, std::string destination, std::string objectPath)
+            : ProxyObjectHolder(createProxy(connection, std::move(destination), std::move(objectPath)))
+            , _Interfaces(getProxy())...
+        {
+        }
+
+        /*!
+         * @brief Creates native-like proxy object instance
+         *
+         * @param[in] connection D-Bus connection to be used by the proxy object
+         * @param[in] destination Bus name that provides a D-Bus object
+         * @param[in] objectPath Path of the D-Bus object
+         *
+         * The proxy created this way becomes an owner of the connection.
+         * For more information on its behavior, consult @ref createProxy(std::unique_ptr<sdbus::IConnection>&&,std::string,std::string)
+         */
+        ProxyInterfaces(std::unique_ptr<sdbus::IConnection>&& connection, std::string destination, std::string objectPath)
+            : ProxyObjectHolder(createProxy(std::move(connection), std::move(destination), std::move(objectPath)))
+            , _Interfaces(getProxy())...
+        {
+        }
+
+        /*!
+         * @brief Finishes proxy registration and makes the proxy ready for use
+         *
+         * This function must be called in the constructor of the final proxy class that implements ProxyInterfaces.
+         *
+         * For more information, see underlying @ref IProxy::finishRegistration()
+         */
+        void registerProxy()
+        {
+            getProxy().finishRegistration();
+        }
+
+        /*!
+         * @brief Unregisters the proxy so it no more receives signals and async call replies
+         *
+         * This function must be called in the destructor of the final proxy class that implements ProxyInterfaces.
+         *
+         * See underlying @ref IProxy::unregister()
+         */
+        void unregisterProxy()
+        {
+            getProxy().unregister();
+        }
+
+        /*!
+         * @brief Returns object path of the underlying DBus object
+         */
+        const std::string& getObjectPath() const
+        {
+            return getProxy().getObjectPath();
+        }
+
+    protected:
+        using base_type = ProxyInterfaces;
+    };
+
+}
+
+#endif /* SDBUS_CXX_INTERFACES_H_ */

include/sdbus-c++/StandardInterfaces.h

@@ -0,0 +1,262 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file StandardInterfaces.h
+ *
+ * Created on: Dec 13, 2016
+ * 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_STANDARDINTERFACES_H_
+#define SDBUS_CXX_STANDARDINTERFACES_H_
+
+#include <sdbus-c++/IObject.h>
+#include <sdbus-c++/IProxy.h>
+#include <sdbus-c++/Types.h>
+#include <string>
+#include <map>
+#include <vector>
+
+namespace sdbus {
+
+    // Proxy for peer
+    class Peer_proxy
+    {
+        static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.Peer";
+
+    protected:
+        Peer_proxy(sdbus::IProxy& proxy)
+            : proxy_(proxy)
+        {
+        }
+
+        ~Peer_proxy() = default;
+
+    public:
+        void Ping()
+        {
+            proxy_.callMethod("Ping").onInterface(INTERFACE_NAME);
+        }
+
+        std::string GetMachineId()
+        {
+            std::string machineUUID;
+            proxy_.callMethod("GetMachineId").onInterface(INTERFACE_NAME).storeResultsTo(machineUUID);
+            return machineUUID;
+        }
+
+    private:
+        sdbus::IProxy& proxy_;
+    };
+
+    // Proxy for introspection
+    class Introspectable_proxy
+    {
+        static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.Introspectable";
+
+    protected:
+        Introspectable_proxy(sdbus::IProxy& proxy)
+            : proxy_(proxy)
+        {
+        }
+
+        ~Introspectable_proxy() = default;
+
+    public:
+        std::string Introspect()
+        {
+            std::string xml;
+            proxy_.callMethod("Introspect").onInterface(INTERFACE_NAME).storeResultsTo(xml);
+            return xml;
+        }
+
+    private:
+        sdbus::IProxy& proxy_;
+    };
+
+    // Proxy for properties
+    class Properties_proxy
+    {
+        static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.Properties";
+
+    protected:
+        Properties_proxy(sdbus::IProxy& proxy)
+            : proxy_(proxy)
+        {
+            proxy_
+                .uponSignal("PropertiesChanged")
+                .onInterface(INTERFACE_NAME)
+                .call([this]( const std::string& interfaceName
+                            , const std::map<std::string, sdbus::Variant>& changedProperties
+                            , const std::vector<std::string>& invalidatedProperties )
+                            {
+                                this->onPropertiesChanged(interfaceName, changedProperties, invalidatedProperties);
+                            });
+        }
+
+        ~Properties_proxy() = default;
+
+        virtual void onPropertiesChanged( const std::string& interfaceName
+                                        , const std::map<std::string, sdbus::Variant>& changedProperties
+                                        , const std::vector<std::string>& invalidatedProperties ) = 0;
+
+    public:
+        sdbus::Variant Get(const std::string& interfaceName, const std::string& propertyName)
+        {
+            return proxy_.getProperty(propertyName).onInterface(interfaceName);
+        }
+
+        void Set(const std::string& interfaceName, const std::string& propertyName, const sdbus::Variant& value)
+        {
+            proxy_.setProperty(propertyName).onInterface(interfaceName).toValue(value);
+        }
+
+        std::map<std::string, sdbus::Variant> GetAll(const std::string& interfaceName)
+        {
+            std::map<std::string, sdbus::Variant> props;
+            proxy_.callMethod("GetAll").onInterface(INTERFACE_NAME).withArguments(interfaceName).storeResultsTo(props);
+            return props;
+        }
+
+    private:
+        sdbus::IProxy& proxy_;
+    };
+
+    // Proxy for object manager
+    class ObjectManager_proxy
+    {
+        static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.ObjectManager";
+
+    protected:
+        ObjectManager_proxy(sdbus::IProxy& proxy)
+            : proxy_(proxy)
+        {
+            proxy_
+                .uponSignal("InterfacesAdded")
+                .onInterface(INTERFACE_NAME)
+                .call([this]( const sdbus::ObjectPath& objectPath
+                            , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+                            {
+                                this->onInterfacesAdded(objectPath, interfacesAndProperties);
+                            });
+
+            proxy_
+                .uponSignal("InterfacesRemoved")
+                .onInterface(INTERFACE_NAME)
+                .call([this]( const sdbus::ObjectPath& objectPath
+                            , const std::vector<std::string>& interfaces )
+                            {
+                                this->onInterfacesRemoved(objectPath, interfaces);
+                            });
+        }
+
+        ~ObjectManager_proxy() = default;
+
+        virtual void onInterfacesAdded( const sdbus::ObjectPath& objectPath
+                                      , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties) = 0;
+        virtual void onInterfacesRemoved( const sdbus::ObjectPath& objectPath
+                                        , const std::vector<std::string>& interfaces) = 0;
+
+    public:
+        std::map<sdbus::ObjectPath, std::map<std::string, std::map<std::string, sdbus::Variant>>> GetManagedObjects()
+        {
+            std::map<sdbus::ObjectPath, std::map<std::string, std::map<std::string, sdbus::Variant>>> objectsInterfacesAndProperties;
+            proxy_.callMethod("GetManagedObjects").onInterface(INTERFACE_NAME).storeResultsTo(objectsInterfacesAndProperties);
+            return objectsInterfacesAndProperties;
+        }
+
+    private:
+        sdbus::IProxy& proxy_;
+    };
+
+    // 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.
+
+    // Adaptor for properties
+    class Properties_adaptor
+    {
+        static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.Properties";
+
+    protected:
+        Properties_adaptor(sdbus::IObject& object)
+            : object_(object)
+        {
+        }
+
+        ~Properties_adaptor() = default;
+
+    public:
+        void emitPropertiesChangedSignal(const std::string& interfaceName, const std::vector<std::string>& properties)
+        {
+            object_.emitPropertiesChangedSignal(interfaceName, properties);
+        }
+
+        void emitPropertiesChangedSignal(const std::string& interfaceName)
+        {
+            object_.emitPropertiesChangedSignal(interfaceName);
+        }
+
+    private:
+        sdbus::IObject& object_;
+    };
+
+    // Adaptor for object manager
+    class ObjectManager_adaptor
+    {
+        static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.ObjectManager";
+
+    protected:
+        ObjectManager_adaptor(sdbus::IObject& object)
+            : object_(object)
+        {
+            object_.addObjectManager();
+        }
+
+        ~ObjectManager_adaptor() = default;
+
+    public:
+        void emitInterfacesAddedSignal()
+        {
+            object_.emitInterfacesAddedSignal();
+        }
+
+        void emitInterfacesAddedSignal(const std::vector<std::string>& interfaces)
+        {
+            object_.emitInterfacesAddedSignal(interfaces);
+        }
+
+        void emitInterfacesRemovedSignal()
+        {
+            object_.emitInterfacesRemovedSignal();
+        }
+
+        void emitInterfacesRemovedSignal(const std::vector<std::string>& interfaces)
+        {
+            object_.emitInterfacesRemovedSignal(interfaces);
+        }
+
+    private:
+        sdbus::IObject& object_;
+    };
+
+}
+
+#endif /* SDBUS_CXX_STANDARDINTERFACES_H_ */

include/sdbus-c++/TypeTraits.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file TypeTraits.h
  *
@@ -40,23 +41,23 @@ namespace sdbus {
     template <typename... _ValueTypes> class Struct;
     class ObjectPath;
     class Signature;
-    class Message;
+    struct UnixFd;
     class MethodCall;
     class MethodReply;
     class Signal;
-    class MethodResult;
+    class PropertySetCall;
+    class PropertyGetReply;
     template <typename... _Results> class Result;
     class Error;
 }
 
 namespace sdbus {
 
-    using method_callback = std::function<void(MethodCall& msg, MethodReply& reply)>;
-    using async_method_callback = std::function<void(MethodCall msg, MethodResult&& result)>;
+    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 property_set_callback = std::function<void(Message& msg)>;
-    using property_get_callback = std::function<void(Message& reply)>;
+    using property_set_callback = std::function<void(PropertySetCall& msg)>;
+    using property_get_callback = std::function<void(PropertyGetReply& reply)>;
 
     template <typename _T>
     struct signature_of
@@ -244,11 +245,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;
         }
@@ -287,6 +286,17 @@ namespace sdbus {
         }
     };
 
+    template <>
+    struct signature_of<UnixFd>
+    {
+        static constexpr bool is_valid = true;
+
+        static const std::string str()
+        {
+            return "h";
+        }
+    };
+
     template <typename _Element>
     struct signature_of<std::vector<_Element>>
     {
@@ -381,6 +391,7 @@ namespace sdbus {
         : public function_traits_base<std::tuple<_Results...>, _Args...>
     {
         static constexpr bool is_async = true;
+        using async_result_t = Result<_Results...>;
     };
 
     template <typename... _Args, typename... _Results>
@@ -388,6 +399,7 @@ namespace sdbus {
         : public function_traits_base<std::tuple<_Results...>, _Args...>
     {
         static constexpr bool is_async = true;
+        using async_result_t = Result<_Results...>;
     };
 
     template <typename _ReturnType, typename... _Args>
@@ -475,11 +487,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;
         }
     };
@@ -504,9 +513,9 @@ namespace sdbus {
 
     namespace detail
     {
-        template <class _Function, class _Tuple, std::size_t... _I>
+        template <class _Function, class _Tuple, typename... _Args, std::size_t... _I>
         constexpr decltype(auto) apply_impl( _Function&& f
-                                           , MethodResult&& r
+                                           , Result<_Args...>&& r
                                            , _Tuple&& t
                                            , std::index_sequence<_I...> )
         {
@@ -522,27 +531,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<>{};
         }
     }
 
@@ -558,8 +557,8 @@ namespace sdbus {
 
     // Convert tuple `t' of values into a list of arguments
     // and invoke function `f' with those arguments.
-    template <class _Function, class _Tuple>
-    constexpr decltype(auto) apply(_Function&& f, MethodResult&& r, _Tuple&& t)
+    template <class _Function, class _Tuple, typename... _Args>
+    constexpr decltype(auto) apply(_Function&& f, Result<_Args...>&& r, _Tuple&& t)
     {
         return detail::apply_impl( std::forward<_Function>(f)
                                  , std::move(r)

include/sdbus-c++/Types.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Types.h
  *
@@ -33,6 +34,7 @@
 #include <typeinfo>
 #include <memory>
 #include <tuple>
+#include <unistd.h>
 
 namespace sdbus {
 
@@ -94,9 +96,15 @@ namespace sdbus {
         std::string peekValueType() const;
 
     private:
-        mutable Message msg_{};
+        mutable PlainMessage msg_{};
     };
 
+    /********************************************//**
+     * @class Struct
+     *
+     * Representation of struct D-Bus type
+     *
+     ***********************************************/
     template <typename... _ValueTypes>
     class Struct
         : public std::tuple<_ValueTypes...>
@@ -135,6 +143,12 @@ namespace sdbus {
         return result_type(std::forward<_Elements>(args)...);
     }
 
+    /********************************************//**
+     * @class ObjectPath
+     *
+     * Representation of object path D-Bus type
+     *
+     ***********************************************/
     class ObjectPath : public std::string
     {
     public:
@@ -146,6 +160,12 @@ namespace sdbus {
         using std::string::operator=;
     };
 
+    /********************************************//**
+     * @class Signature
+     *
+     * Representation of Signature D-Bus type
+     *
+     ***********************************************/
     class Signature : public std::string
     {
     public:
@@ -157,6 +177,102 @@ namespace sdbus {
         using std::string::operator=;
     };
 
+    struct adopt_fd_t { explicit adopt_fd_t() = default; };
+    inline constexpr adopt_fd_t adopt_fd{};
+
+    /********************************************//**
+     * @struct UnixFd
+     *
+     * UnixFd is a representation of file descriptor D-Bus type that owns
+     * the underlying fd, provides access to it, and closes the fd when
+     * the UnixFd goes out of scope.
+     *
+     * UnixFd can be default constructed (owning invalid fd), or constructed from
+     * an explicitly provided fd by either duplicating or adopting that fd as-is.
+     *
+     ***********************************************/
+    class UnixFd
+    {
+    public:
+        UnixFd() = default;
+
+        explicit UnixFd(int fd)
+            : fd_(::dup(fd))
+        {
+        }
+
+        UnixFd(int fd, adopt_fd_t)
+            : fd_(fd)
+        {
+        }
+
+        UnixFd(const UnixFd& other)
+        {
+            *this = other;
+        }
+
+        UnixFd& operator=(const UnixFd& other)
+        {
+            close();
+            fd_ = ::dup(other.fd_);
+            return *this;
+        }
+
+        UnixFd(UnixFd&& other)
+        {
+            *this = std::move(other);
+        }
+
+        UnixFd& operator=(UnixFd&& other)
+        {
+            close();
+            fd_ = other.fd_;
+            other.fd_ = -1;
+            return *this;
+        }
+
+        ~UnixFd()
+        {
+            close();
+        }
+
+        int get() const
+        {
+            return fd_;
+        }
+
+        void reset(int fd = -1)
+        {
+            *this = UnixFd{fd};
+        }
+
+        void reset(int fd, adopt_fd_t)
+        {
+            *this = UnixFd{fd, adopt_fd};
+        }
+
+        int release()
+        {
+            auto fd = fd_;
+            fd_ = -1;
+            return fd;
+        }
+
+        bool isValid() const
+        {
+            return fd_ >= 0;
+        }
+
+    private:
+        void close()
+        {
+            if (fd_ >= 0)
+                ::close(fd_);
+        }
+
+        int fd_ = -1;
+    };
+
 }
 
 #endif /* SDBUS_CXX_TYPES_H_ */

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

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file sdbus-c++.h
  *
@@ -25,11 +26,13 @@
 
 #include <sdbus-c++/IConnection.h>
 #include <sdbus-c++/IObject.h>
-#include <sdbus-c++/IObjectProxy.h>
-#include <sdbus-c++/Interfaces.h>
+#include <sdbus-c++/IProxy.h>
+#include <sdbus-c++/AdaptorInterfaces.h>
+#include <sdbus-c++/ProxyInterfaces.h>
+#include <sdbus-c++/StandardInterfaces.h>
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/MethodResult.h>
 #include <sdbus-c++/Types.h>
 #include <sdbus-c++/TypeTraits.h>
-#include <sdbus-c++/Introspection.h>
 #include <sdbus-c++/Error.h>
+#include <sdbus-c++/Flags.h>

sdbus-c++-config.cmake.in

@@ -1,14 +0,0 @@
-# Config file for the sdbus-c++ package.
-#
-# It defines the following variables:
-#  SDBUSCPP_VERSION      - version of sdbus-c++
-#  SDBUSCPP_FOUND        - set to true
-#  SDBUSCPP_INCLUDE_DIRS - include directories for sdbus-c++
-#  SDBUSCPP_LIBRARY_DIR  - library directories for sdbus-c++
-#  SDBUSCPP_LIBRARIES    - libraries to link against
-
-set(SDBUSCPP_VERSION "@SDBUSCPP_VERSION@")
-set(SDBUSCPP_FOUND "TRUE")
-set(SDBUSCPP_INCLUDE_DIRS "@CMAKE_INSTALL_FULL_INCLUDEDIR@")
-set(SDBUSCPP_LIBRARY_DIR "@CMAKE_INSTALL_FULL_LIBDIR@")
-set(SDBUSCPP_LIBRARIES sdbus-c++)

src/Connection.cpp

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Connection.cpp
  *
@@ -25,6 +26,7 @@
 
 #include "Connection.h"
 #include "SdBus.h"
+#include "MessageUtils.h"
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/Error.h>
 #include "ScopeGuard.h"
@@ -33,26 +35,33 @@
 #include <poll.h>
 #include <sys/eventfd.h>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
-Connection::Connection(Connection::BusType type, std::unique_ptr<ISdBus>&& interface)
+Connection::Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& busFactory)
     : iface_(std::move(interface))
-    , busType_(type)
+    , bus_(openBus(busFactory))
 {
     assert(iface_ != nullptr);
+}
 
-    auto bus = openBus(busType_);
-    bus_.reset(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); })
+{
+}
 
-    finishHandshake(bus);
+Connection::Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t)
+    : Connection(std::move(interface), [this](sd_bus** bus){ return iface_->sd_bus_open_user(bus); })
+{
+}
 
-    loopExitFd_ = createProcessingLoopExitDescriptor();
+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()
 {
-    leaveProcessingLoop();
-    closeProcessingLoopExitDescriptor(loopExitFd_);
+    Connection::leaveEventLoop();
 }
 
 void Connection::requestName(const std::string& name)
@@ -67,8 +76,20 @@ void Connection::releaseName(const std::string& name)
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to release bus name", -r);
 }
 
-void Connection::enterProcessingLoop()
+std::string Connection::getUniqueName() const
 {
+    const char* unique = nullptr;
+    auto r = iface_->sd_bus_get_unique_name(bus_.get(), &unique);
+    SDBUS_THROW_ERROR_IF(r < 0 || unique == nullptr, "Failed to get unique bus name", -r);
+    return unique;
+}
+
+void Connection::enterEventLoop()
+{
+    loopThreadId_ = std::this_thread::get_id();
+
+    std::lock_guard guard(loopMutex_);
+
     while (true)
     {
         auto processed = processPendingRequest();
@@ -77,20 +98,31 @@ 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();
+}
+
+Connection::PollData Connection::getEventLoopPollData() const
+{
+    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};
 }
 
 const ISdBus& Connection::getSdBusInterface() const
@@ -103,10 +135,46 @@ ISdBus& Connection::getSdBusInterface()
     return *iface_.get();
 }
 
-sd_bus_slot* Connection::addObjectVTable( const std::string& objectPath
-                                        , const std::string& interfaceName
-                                        , const sd_bus_vtable* vtable
-                                        , void* userData )
+void Connection::addObjectManager(const std::string& objectPath)
+{
+    Connection::addObjectManager(objectPath, nullptr);
+}
+
+SlotPtr Connection::addObjectManager(const std::string& objectPath, void* /*dummy*/)
+{
+    sd_bus_slot *slot{};
+
+    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);
+
+    return {slot, [this](void *slot){ iface_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
+}
+
+void Connection::setMethodCallTimeout(uint64_t timeout)
+{
+    auto r = iface_->sd_bus_set_method_call_timeout(bus_.get(), timeout);
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set method call timeout", -r);
+}
+
+uint64_t Connection::getMethodCallTimeout() const
+{
+    uint64_t timeout;
+
+    auto r = iface_->sd_bus_get_method_call_timeout(bus_.get(), &timeout);
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get method call timeout", -r);
+
+    return timeout;
+}
+
+SlotPtr Connection::addObjectVTable( const std::string& objectPath
+                                   , const std::string& interfaceName
+                                   , const sd_bus_vtable* vtable
+                                   , void* userData )
 {
     sd_bus_slot *slot{};
 
@@ -119,12 +187,18 @@ sd_bus_slot* Connection::addObjectVTable( const std::string& objectPath
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to register object vtable", -r);
 
-    return slot;
+    return {slot, [this](void *slot){ iface_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }
 
-void Connection::removeObjectVTable(sd_bus_slot* vtableHandle)
+PlainMessage Connection::createPlainMessage() const
 {
-    iface_->sd_bus_slot_unref(vtableHandle);
+    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
@@ -143,31 +217,83 @@ MethodCall Connection::createMethodCall( const std::string& destination
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method call", -r);
 
-    return MethodCall{sdbusMsg, iface_.get(), adopt_message};
+    return Message::Factory::create<MethodCall>(sdbusMsg, iface_.get(), 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 Signal{sdbusSignal, iface_.get(), adopt_message};
+    return Message::Factory::create<Signal>(sdbusMsg, iface_.get(), adopt_message);
 }
 
-sd_bus_slot* Connection::registerSignalHandler( const std::string& objectPath
-                                              , const std::string& interfaceName
-                                              , const std::string& signalName
-                                              , sd_bus_message_handler_t callback
-                                              , void* userData )
+void Connection::emitPropertiesChangedSignal( const std::string& objectPath
+                                            , const std::string& interfaceName
+                                            , const std::vector<std::string>& propNames )
+{
+    auto names = to_strv(propNames);
+
+    auto r = iface_->sd_bus_emit_properties_changed_strv( bus_.get()
+                                                        , objectPath.c_str()
+                                                        , interfaceName.c_str()
+                                                        , propNames.empty() ? nullptr : &names[0] );
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit PropertiesChanged signal", -r);
+}
+
+void Connection::emitInterfacesAddedSignal(const std::string& objectPath)
+{
+    auto r = iface_->sd_bus_emit_object_added(bus_.get(), objectPath.c_str());
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit InterfacesAdded signal for all registered interfaces", -r);
+}
+
+void Connection::emitInterfacesAddedSignal( const std::string& objectPath
+                                          , const std::vector<std::string>& interfaces )
+{
+    auto names = to_strv(interfaces);
+
+    auto r = iface_->sd_bus_emit_interfaces_added_strv( bus_.get()
+                                                      , objectPath.c_str()
+                                                      , interfaces.empty() ? nullptr : &names[0] );
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit InterfacesAdded signal", -r);
+}
+
+void Connection::emitInterfacesRemovedSignal(const std::string& objectPath)
+{
+    auto r = iface_->sd_bus_emit_object_removed(bus_.get(), objectPath.c_str());
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit InterfacesRemoved signal for all registered interfaces", -r);
+}
+
+void Connection::emitInterfacesRemovedSignal( const std::string& objectPath
+                                            , const std::vector<std::string>& interfaces )
+{
+    auto names = to_strv(interfaces);
+
+    auto r = iface_->sd_bus_emit_interfaces_removed_strv( bus_.get()
+                                                        , objectPath.c_str()
+                                                        , interfaces.empty() ? nullptr : &names[0] );
+
+    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 )
 {
     sd_bus_slot *slot{};
 
@@ -176,29 +302,47 @@ sd_bus_slot* Connection::registerSignalHandler( const std::string& objectPath
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to register signal handler", -r);
 
-    return slot;
+    return {slot, [this](void *slot){ iface_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }
 
-void Connection::unregisterSignalHandler(sd_bus_slot* handlerCookie)
+MethodReply Connection::tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout)
 {
-    iface_->sd_bus_slot_unref(handlerCookie);
+    auto loopThreadId = loopThreadId_.load(std::memory_order_relaxed);
+
+    // Is the loop not yet on? => Go make synchronous call
+    while (loopThreadId == std::thread::id{})
+    {
+        // Did the loop begin in the meantime? Or try_lock() failed spuriously?
+        if (!loopMutex_.try_lock())
+        {
+            loopThreadId = loopThreadId_.load(std::memory_order_relaxed);
+            continue;
+        }
+
+        // Synchronous D-Bus call
+        std::lock_guard guard(loopMutex_, std::adopt_lock);
+        return message.send(timeout);
+    }
+
+    // Is the loop on and we are in the same thread? => Go for synchronous call
+    if (loopThreadId == std::this_thread::get_id())
+    {
+        assert(!loopMutex_.try_lock());
+        return message.send(timeout);
+    }
+
+    return {};
 }
 
-sd_bus* Connection::openBus(Connection::BusType type)
+Connection::BusPtr Connection::openBus(const BusFactory& busFactory)
 {
     sd_bus* bus{};
-    int r = 0;
-    if (type == BusType::eSystem)
-        r = iface_->sd_bus_open_system(&bus);
-    else if (type == BusType::eSession)
-        r = iface_->sd_bus_open_user(&bus);
-    else
-        assert(false);
-
+    int r = busFactory(&bus);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to open bus", -r);
-    assert(bus != nullptr);
 
-    return bus;
+    BusPtr busPtr{bus, [this](sd_bus* bus){ return iface_->sd_bus_flush_close_unref(bus); }};
+    finishHandshake(busPtr.get());
+    return busPtr;
 }
 
 void Connection::finishHandshake(sd_bus* bus)
@@ -214,37 +358,23 @@ void Connection::finishHandshake(sd_bus* bus)
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to flush bus on opening", -r);
 }
 
-int Connection::createProcessingLoopExitDescriptor()
+void Connection::notifyEventLoopToExit()
 {
-    auto r = eventfd(0, EFD_SEMAPHORE | EFD_CLOEXEC | EFD_NONBLOCK);
-
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create event object", -errno);
-
-    return r;
-}
-
-void Connection::closeProcessingLoopExitDescriptor(int fd)
-{
-    close(fd);
-}
-
-void Connection::notifyProcessingLoopToExit()
-{
-    assert(loopExitFd_ >= 0);
+    assert(loopExitFd_.fd >= 0);
 
     uint64_t value = 1;
-    auto r = write(loopExitFd_, &value, sizeof(value));
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to notify processing loop", -errno);
+    auto r = write(loopExitFd_.fd, &value, sizeof(value));
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to notify event loop", -errno);
 }
 
 void Connection::clearExitNotification()
 {
     uint64_t value{};
-    auto r = read(loopExitFd_, &value, sizeof(value));
+    auto r = read(loopExitFd_.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();
@@ -253,11 +383,9 @@ void Connection::joinWithProcessingLoop()
 bool Connection::processPendingRequest()
 {
     auto bus = bus_.get();
-
     assert(bus != nullptr);
 
     int r = iface_->sd_bus_process(bus, nullptr);
-
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to process bus requests", -r);
 
     return r > 0;
@@ -268,17 +396,14 @@ bool Connection::waitForNextRequest()
     auto bus = bus_.get();
 
     assert(bus != nullptr);
-    assert(loopExitFd_ != 0);
+    assert(loopExitFd_.fd != 0);
 
-    ISdBus::PollData sdbusPollData;
-    auto r = iface_->sd_bus_get_poll_data(bus, &sdbusPollData);
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus poll data", -r);
-
-    struct pollfd fds[] = {{sdbusPollData.fd, sdbusPollData.events, 0}, {loopExitFd_, POLLIN, 0}};
+    auto sdbusPollData = getEventLoopPollData();
+    struct pollfd fds[] = {{sdbusPollData.fd, sdbusPollData.events, 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;
-    r = poll(fds, fdsCount, timeout);
+    auto r = poll(fds, fdsCount, timeout);
 
     if (r < 0 && errno == EINTR)
         return true; // Try again
@@ -308,7 +433,40 @@ std::string Connection::composeSignalMatchFilter( const std::string& objectPath
     return filter;
 }
 
-}}
+std::vector</*const */char*> Connection::to_strv(const std::vector<std::string>& strings)
+{
+    std::vector</*const */char*> strv;
+    for (auto& str : strings)
+        strv.push_back(const_cast<char*>(str.c_str()));
+    strv.push_back(nullptr);
+    return strv;
+}
+
+Connection::LoopExitEventFd::LoopExitEventFd()
+{
+    fd = eventfd(0, EFD_SEMAPHORE | EFD_CLOEXEC | EFD_NONBLOCK);
+    SDBUS_THROW_ERROR_IF(fd < 0, "Failed to create event object", -errno);
+}
+
+Connection::LoopExitEventFd::~LoopExitEventFd()
+{
+    assert(fd >= 0);
+    close(fd);
+}
+
+}
+
+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);
+}
+
+}
 
 namespace sdbus {
 
@@ -326,8 +484,8 @@ std::unique_ptr<sdbus::IConnection> createSystemBusConnection()
 {
     auto interface = std::make_unique<sdbus::internal::SdBus>();
     assert(interface != nullptr);
-    return std::make_unique<sdbus::internal::Connection>( sdbus::internal::Connection::BusType::eSystem
-                                                        , std::move(interface));
+    constexpr sdbus::internal::Connection::system_bus_t system_bus;
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), system_bus);
 }
 
 std::unique_ptr<sdbus::IConnection> createSystemBusConnection(const std::string& name)
@@ -341,8 +499,8 @@ std::unique_ptr<sdbus::IConnection> createSessionBusConnection()
 {
     auto interface = std::make_unique<sdbus::internal::SdBus>();
     assert(interface != nullptr);
-    return std::make_unique<sdbus::internal::Connection>( sdbus::internal::Connection::BusType::eSession
-                                                        , std::move(interface));
+    constexpr sdbus::internal::Connection::session_bus_t session_bus;
+    return std::make_unique<sdbus::internal::Connection>(std::move(interface), session_bus);
 }
 
 std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string& name)
@@ -352,4 +510,12 @@ std::unique_ptr<sdbus::IConnection> createSessionBusConnection(const std::string
     return conn;
 }
 
+std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host)
+{
+    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);
+}
+
 }

src/Connection.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Connection.h
  *
@@ -34,38 +35,52 @@
 #include <systemd/sd-bus.h>
 #include <memory>
 #include <thread>
+#include <string>
+#include <vector>
+#include <atomic>
+#include <mutex>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
-    class Connection
+    class Connection final
         : public sdbus::IConnection           // External, public interface
         , public sdbus::internal::IConnection // Internal, private interface
     {
     public:
-        enum class BusType
-        {
-            eSystem,
-            eSession
-        };
+        // Bus type tags
+        struct system_bus_t{};
+        struct session_bus_t{};
+        struct remote_system_bus_t{};
 
-        Connection(BusType type, std::unique_ptr<ISdBus>&& interface);
+        Connection(std::unique_ptr<ISdBus>&& interface, system_bus_t);
+        Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t);
+        Connection(std::unique_ptr<ISdBus>&& interface, remote_system_bus_t, const std::string& host);
         ~Connection() override;
 
         void requestName(const std::string& name) override;
         void releaseName(const std::string& name) override;
-        void enterProcessingLoop() override;
-        void enterProcessingLoopAsync() override;
-        void leaveProcessingLoop() override;
+        std::string getUniqueName() 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 setMethodCallTimeout(uint64_t timeout) override;
+        uint64_t getMethodCallTimeout() const override;
 
         const ISdBus& getSdBusInterface() const override;
         ISdBus& getSdBusInterface() override;
 
-        sd_bus_slot* addObjectVTable( const std::string& objectPath
-                                    , const std::string& interfaceName
-                                    , const sd_bus_vtable* vtable
-                                    , void* userData ) override;
-        void removeObjectVTable(sd_bus_slot* vtableHandle) override;
+        SlotPtr 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
@@ -74,39 +89,56 @@ namespace sdbus { namespace internal {
                            , const std::string& interfaceName
                            , const std::string& signalName ) const override;
 
-        sd_bus_slot* registerSignalHandler( const std::string& objectPath
-                                          , const std::string& interfaceName
-                                          , const std::string& signalName
-                                          , sd_bus_message_handler_t callback
-                                          , void* userData ) override;
-        void unregisterSignalHandler(sd_bus_slot* handlerCookie) override;
+        void emitPropertiesChangedSignal( const std::string& objectPath
+                                        , const std::string& interfaceName
+                                        , const std::vector<std::string>& propNames ) override;
+        void emitInterfacesAddedSignal(const std::string& objectPath) override;
+        void emitInterfacesAddedSignal( const std::string& objectPath
+                                      , const std::vector<std::string>& interfaces ) override;
+        void emitInterfacesRemovedSignal(const std::string& objectPath) override;
+        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;
+
+        MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) override;
 
     private:
-        sd_bus* openBus(Connection::BusType type);
+        using BusFactory = std::function<int(sd_bus**)>;
+        using BusPtr = std::unique_ptr<sd_bus, std::function<sd_bus*(sd_bus*)>>;
+        Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& busFactory);
+
+        BusPtr openBus(const std::function<int(sd_bus**)>& busFactory);
         void finishHandshake(sd_bus* bus);
-        static int createProcessingLoopExitDescriptor();
-        static void closeProcessingLoopExitDescriptor(int fd);
-        bool processPendingRequest();
         bool waitForNextRequest();
         static std::string composeSignalMatchFilter( const std::string& objectPath
                                                    , const std::string& interfaceName
                                                    , const std::string& signalName );
-        void notifyProcessingLoopToExit();
+        void notifyEventLoopToExit();
         void clearExitNotification();
-        void joinWithProcessingLoop();
+        void joinWithEventLoop();
+        static std::vector</*const */char*> to_strv(const std::vector<std::string>& strings);
+
+        struct LoopExitEventFd
+        {
+            LoopExitEventFd();
+            ~LoopExitEventFd();
+            int fd;
+        };
 
     private:
         std::unique_ptr<ISdBus> iface_;
-        std::unique_ptr<sd_bus, std::function<sd_bus*(sd_bus*)>> bus_ {nullptr, [this](sd_bus* bus)
-                                                                                {
-                                                                                    return iface_->sd_bus_flush_close_unref(bus);
-                                                                                }};
-        BusType busType_;
-
+        BusPtr bus_;
         std::thread asyncLoopThread_;
-        int loopExitFd_{-1};
+        std::atomic<std::thread::id> loopThreadId_;
+        std::mutex loopMutex_;
+        LoopExitEventFd loopExitFd_;
     };
 
-}}
+}
 
 #endif /* SDBUS_CXX_INTERNAL_CONNECTION_H_ */

src/ConvenienceClasses.cpp

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

src/Error.cpp

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

src/Flags.cpp

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

src/IConnection.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file IConnection.h
  *
@@ -29,56 +30,72 @@
 #include <systemd/sd-bus.h>
 #include <string>
 #include <memory>
+#include <functional>
+#include <vector>
 
 // Forward declaration
 namespace sdbus {
     class MethodCall;
-    class AsyncMethodCall;
     class MethodReply;
     class Signal;
+    class PlainMessage;
     namespace internal {
         class ISdBus;
     }
 }
 
-namespace sdbus {
-namespace internal {
+namespace sdbus::internal {
+
+    using SlotPtr = std::unique_ptr<void, std::function<void(void*)>>;
 
     class IConnection
     {
     public:
+        virtual ~IConnection() = default;
+
         virtual const ISdBus& getSdBusInterface() const = 0;
         virtual ISdBus& getSdBusInterface() = 0;
 
-        virtual sd_bus_slot* addObjectVTable( const std::string& objectPath
-                                            , const std::string& interfaceName
-                                            , const sd_bus_vtable* vtable
-                                            , void* userData ) = 0;
-        virtual void removeObjectVTable(sd_bus_slot* vtableHandle) = 0;
+        [[nodiscard]] virtual SlotPtr 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;
 
-        virtual sd_bus_slot* registerSignalHandler( const std::string& objectPath
-                                                  , const std::string& interfaceName
-                                                  , const std::string& signalName
-                                                  , sd_bus_message_handler_t callback
-                                                  , void* userData ) = 0;
-        virtual void unregisterSignalHandler(sd_bus_slot* handlerCookie) = 0;
+        virtual void emitPropertiesChangedSignal( const std::string& objectPath
+                                                , const std::string& interfaceName
+                                                , const std::vector<std::string>& propNames ) = 0;
+        virtual void emitInterfacesAddedSignal(const std::string& objectPath) = 0;
+        virtual void emitInterfacesAddedSignal( const std::string& objectPath
+                                              , const std::vector<std::string>& interfaces ) = 0;
+        virtual void emitInterfacesRemovedSignal(const std::string& objectPath) = 0;
+        virtual void emitInterfacesRemovedSignal( const std::string& objectPath
+                                                , const std::vector<std::string>& interfaces ) = 0;
 
-        virtual void enterProcessingLoopAsync() = 0;
-        virtual void leaveProcessingLoop() = 0;
+        [[nodiscard]] virtual SlotPtr addObjectManager(const std::string& objectPath, void* /*dummy*/ = nullptr) = 0;
 
-        virtual ~IConnection() = default;
+        [[nodiscard]] 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 enterEventLoopAsync() = 0;
+        virtual void leaveEventLoop() = 0;
+
+        virtual MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) = 0;
     };
 
-}
+    [[nodiscard]] std::unique_ptr<sdbus::internal::IConnection> createConnection();
+
 }
 
 #endif /* SDBUS_CXX_INTERNAL_ICONNECTION_H_ */

src/ISdBus.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file ISdBus.h
  * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@@ -29,7 +30,7 @@
 
 #include <systemd/sd-bus.h>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
     class ISdBus
     {
@@ -41,6 +42,8 @@ namespace sdbus { namespace internal {
             uint64_t timeout_usec;
         };
 
+        virtual ~ISdBus() = default;
+
         virtual sd_bus_message* sd_bus_message_ref(sd_bus_message *m) = 0;
         virtual sd_bus_message* sd_bus_message_unref(sd_bus_message *m) = 0;
 
@@ -48,16 +51,29 @@ 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;
         virtual int sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message **m, const sd_bus_error *e) = 0;
 
+        virtual int sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec) = 0;
+        virtual int sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret) = 0;
+
+        virtual int sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names) = 0;
+        virtual int sd_bus_emit_object_added(sd_bus *bus, const char *path) = 0;
+        virtual int sd_bus_emit_object_removed(sd_bus *bus, const char *path) = 0;
+        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_system(sd_bus **ret) = 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;
+        virtual int sd_bus_get_unique_name(sd_bus *bus, const char **name) = 0;
         virtual int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata) = 0;
+        virtual int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path) = 0;
         virtual int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) = 0;
         virtual sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) = 0;
 
@@ -66,10 +82,8 @@ namespace sdbus { namespace internal {
 
         virtual int sd_bus_flush(sd_bus *bus) = 0;
         virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) = 0;
-
-        virtual ~ISdBus() = default;
     };
 
-}}
+}
 
 #endif //SDBUS_CXX_ISDBUS_H

src/Message.cpp

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Message.cpp
  *
@@ -27,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>
@@ -210,7 +212,16 @@ Message& Message::operator<<(const ObjectPath &item)
 Message& Message::operator<<(const Signature &item)
 {
     auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_SIGNATURE, item.c_str());
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to serialize an Signature value", -r);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to serialize a Signature value", -r);
+
+    return *this;
+}
+
+Message& Message::operator<<(const UnixFd &item)
+{
+    auto fd = item.get();
+    auto r = sd_bus_message_append_basic((sd_bus_message*)msg_, SD_BUS_TYPE_UNIX_FD, &fd);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to serialize a UnixFd value", -r);
 
     return *this;
 }
@@ -383,6 +394,20 @@ Message& Message::operator>>(Signature &item)
     return *this;
 }
 
+Message& Message::operator>>(UnixFd &item)
+{
+    int fd = -1;
+    auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_UNIX_FD, &fd);
+    if (r == 0)
+        ok_ = false;
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to deserialize a UnixFd value", -r);
+
+    item.reset(fd);
+
+    return *this;
+}
+
 
 Message& Message::openContainer(const std::string& signature)
 {
@@ -566,6 +591,11 @@ std::string Message::getMemberName() const
     return sd_bus_message_get_member((sd_bus_message*)msg_);
 }
 
+std::string Message::getSender() const
+{
+    return sd_bus_message_get_sender((sd_bus_message*)msg_);
+}
+
 void Message::peekType(std::string& type, std::string& contents) const
 {
     char typeSig;
@@ -583,7 +613,7 @@ bool Message::isValid() const
 
 bool Message::isEmpty() const
 {
-    return sd_bus_message_is_empty((sd_bus_message*)msg_);
+    return sd_bus_message_is_empty((sd_bus_message*)msg_) != 0;
 }
 
 void MethodCall::dontExpectReply()
@@ -596,31 +626,31 @@ bool MethodCall::doesntExpectReply() const
 {
     auto r = sd_bus_message_get_expect_reply((sd_bus_message*)msg_);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to get the dont-expect-reply flag", -r);
-    return r > 0 ? false : true;
+    return r == 0;
 }
 
-MethodReply MethodCall::send() const
+MethodReply MethodCall::send(uint64_t timeout) const
 {
     if (!doesntExpectReply())
-        return sendWithReply();
+        return sendWithReply(timeout);
     else
         return sendWithNoReply();
 }
 
-MethodReply MethodCall::sendWithReply() const
+MethodReply MethodCall::sendWithReply(uint64_t timeout) const
 {
     sd_bus_error sdbusError = SD_BUS_ERROR_NULL;
     SCOPE_EXIT{ sd_bus_error_free(&sdbusError); };
 
     sd_bus_message* sdbusReply{};
-    auto r = sdbus_->sd_bus_call(nullptr, (sd_bus_message*)msg_, 0, &sdbusError, &sdbusReply);
+    auto r = sdbus_->sd_bus_call(nullptr, (sd_bus_message*)msg_, timeout, &sdbusError, &sdbusReply);
 
     if (sd_bus_error_is_set(&sdbusError))
         throw sdbus::Error(sdbusError.name, sdbusError.message);
 
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
 
-    return MethodReply{sdbusReply, sdbus_, adopt_message};
+    return Factory::create<MethodReply>(sdbusReply, sdbus_, adopt_message);
 }
 
 MethodReply MethodCall::sendWithNoReply() const
@@ -628,7 +658,23 @@ 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);
 
-    return MethodReply{}; // No reply
+    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::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); }};
 }
 
 MethodReply MethodCall::createReply() const
@@ -637,7 +683,7 @@ MethodReply MethodCall::createReply() const
     auto r = sdbus_->sd_bus_message_new_method_return((sd_bus_message*)msg_, &sdbusReply);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method reply", -r);
 
-    return MethodReply{sdbusReply, sdbus_, adopt_message};
+    return Factory::create<MethodReply>(sdbusReply, sdbus_, adopt_message);
 }
 
 MethodReply MethodCall::createErrorReply(const Error& error) const
@@ -650,18 +696,7 @@ MethodReply MethodCall::createErrorReply(const Error& error) const
     auto r = sdbus_->sd_bus_message_new_method_error((sd_bus_message*)msg_, &sdbusErrorReply, &sdbusError);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method error reply", -r);
 
-    return MethodReply{sdbusErrorReply, sdbus_, adopt_message};
-}
-
-AsyncMethodCall::AsyncMethodCall(MethodCall&& call) noexcept
-    : Message(std::move(call))
-{
-}
-
-void AsyncMethodCall::send(void* callback, void* userData) const
-{
-    auto r = sdbus_->sd_bus_call_async(nullptr, nullptr, (sd_bus_message*)msg_, (sd_bus_message_handler_t)callback, userData, 0);
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method asynchronously", -r);
+    return Factory::create<MethodReply>(sdbusErrorReply, sdbus_, adopt_message);
 }
 
 void MethodReply::send() const
@@ -676,29 +711,10 @@ void Signal::send() const
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit signal", -r);
 }
 
-Message createPlainMessage()
+PlainMessage createPlainMessage()
 {
-    int r;
-
-    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
-    {
-        BusReferenceKeeper(sd_bus* bus) : bus_(bus) {}
-        ~BusReferenceKeeper() { sd_bus_unref(bus_); }
-        sd_bus* bus_{};
-    } busReferenceKeeper{bus};
-
-    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);
-
-    thread_local internal::SdBus sdbus;
-
-    return Message{sdbusMsg, &sdbus, adopt_message};
+    static auto connection = internal::createConnection();
+    return connection->createPlainMessage();
 }
 
 }

src/MessageUtils.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file MessageUtils.h
  *
@@ -30,7 +31,35 @@
 
 namespace sdbus
 {
-    Message createPlainMessage();
+    class Message::Factory
+    {
+    public:
+        template<typename _Msg>
+        static _Msg create()
+        {
+            return _Msg{};
+        }
+
+        template<typename _Msg>
+        static _Msg create(void *msg)
+        {
+            return _Msg{msg};
+        }
+
+        template<typename _Msg>
+        static _Msg create(void *msg, internal::ISdBus* sdbus)
+        {
+            return _Msg{msg, sdbus};
+        }
+
+        template<typename _Msg>
+        static _Msg create(void *msg, internal::ISdBus* sdbus, adopt_message_t)
+        {
+            return _Msg{msg, sdbus, adopt_message};
+        }
+    };
+
+    PlainMessage createPlainMessage();
 }
 
 #endif /* SDBUS_CXX_INTERNAL_MESSAGEUTILS_H_ */

src/Object.cpp

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Object.cpp
  *
@@ -24,6 +25,7 @@
  */
 
 #include "Object.h"
+#include "MessageUtils.h"
 #include <sdbus-c++/IConnection.h>
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/Error.h>
@@ -35,7 +37,7 @@
 #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))
@@ -43,80 +45,83 @@ Object::Object(sdbus::internal::IConnection& connection, std::string 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_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);
 
-    auto syncCallback = [callback = std::move(methodCallback)](MethodCall& msg)
-    {
-        auto reply = msg.createReply();
-        callback(msg, reply);
-        reply.send();
-    };
-
     auto& interface = interfaces_[interfaceName];
-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(syncCallback), flags};
-    auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
-
-    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
-}
-
-void Object::registerMethod( const std::string& interfaceName
-                           , const std::string& methodName
-                           , const std::string& inputSignature
-                           , const std::string& outputSignature
-                           , async_method_callback asyncMethodCallback
-                           , Flags flags )
-{
-    SDBUS_THROW_ERROR_IF(!asyncMethodCallback, "Invalid method callback provided", EINVAL);
-
-    auto asyncCallback = [callback = std::move(asyncMethodCallback)](MethodCall& msg)
-    {
-        MethodResult result{msg};
-        callback(std::move(msg), std::move(result));
-    };
-
-    auto& interface = interfaces_[interfaceName];
-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(asyncCallback), flags};
-    auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
+    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 )
+{
+    registerSignal(interfaceName, std::move(signalName), std::move(signature), {}, std::move(flags));
+}
+
+void Object::registerSignal( const std::string& interfaceName
+                           , std::string signalName
+                           , std::string signature
+                           , const std::vector<std::string>& paramNames
                            , Flags flags )
 {
     auto& interface = interfaces_[interfaceName];
 
-    InterfaceData::SignalData signalData{signature, flags};
-    auto inserted = interface.signals_.emplace(signalName, std::move(signalData)).second;
+    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 )
@@ -125,8 +130,11 @@ void Object::registerProperty( const std::string& interfaceName
 
     auto& interface = interfaces_[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);
 }
@@ -134,7 +142,7 @@ void Object::registerProperty( const std::string& interfaceName
 void Object::setInterfaceFlags(const std::string& interfaceName, Flags flags)
 {
     auto& interface = interfaces_[interfaceName];
-    interface.flags_ = flags;
+    interface.flags = flags;
 }
 
 void Object::finishRegistration()
@@ -149,6 +157,12 @@ void Object::finishRegistration()
     }
 }
 
+void Object::unregister()
+{
+    interfaces_.clear();
+    removeObjectManager();
+}
+
 sdbus::Signal Object::createSignal(const std::string& interfaceName, const std::string& signalName)
 {
     return connection_.createSignal(objectPath_, interfaceName, signalName);
@@ -156,15 +170,72 @@ sdbus::Signal Object::createSignal(const std::string& interfaceName, const std::
 
 void Object::emitSignal(const sdbus::Signal& message)
 {
+    SDBUS_THROW_ERROR_IF(!message.isValid(), "Invalid signal message provided", EINVAL);
+
     message.send();
 }
 
+void Object::emitPropertiesChangedSignal(const std::string& interfaceName, const std::vector<std::string>& propNames)
+{
+    connection_.emitPropertiesChangedSignal(objectPath_, interfaceName, propNames);
+}
+
+void Object::emitPropertiesChangedSignal(const std::string& interfaceName)
+{
+    Object::emitPropertiesChangedSignal(interfaceName, {});
+}
+
+void Object::emitInterfacesAddedSignal()
+{
+    connection_.emitInterfacesAddedSignal(objectPath_);
+}
+
+void Object::emitInterfacesAddedSignal(const std::vector<std::string>& interfaces)
+{
+    connection_.emitInterfacesAddedSignal(objectPath_, interfaces);
+}
+
+void Object::emitInterfacesRemovedSignal()
+{
+    connection_.emitInterfacesRemovedSignal(objectPath_);
+}
+
+void Object::emitInterfacesRemovedSignal(const std::vector<std::string>& interfaces)
+{
+    connection_.emitInterfacesRemovedSignal(objectPath_, interfaces);
+}
+
+void Object::addObjectManager()
+{
+    objectManagerSlot_ = connection_.addObjectManager(objectPath_);
+}
+
+void Object::removeObjectManager()
+{
+    objectManagerSlot_.reset();
+}
+
+bool Object::hasObjectManager() const
+{
+    return objectManagerSlot_ != nullptr;
+}
+
+sdbus::IConnection& Object::getConnection() const
+{
+    return dynamic_cast<sdbus::IConnection&>(connection_);
+}
+
+const std::string& Object::getObjectPath() const
+{
+    return objectPath_;
+}
+
 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);
@@ -175,14 +246,15 @@ 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() ));
     }
@@ -190,35 +262,36 @@ void Object::registerMethodsToVTable(const InterfaceData& interfaceData, std::ve
 
 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() ));
     }
 }
 
@@ -226,10 +299,15 @@ void Object::activateInterfaceVTable( const std::string& interfaceName
                                     , InterfaceData& interfaceData
                                     , const std::vector<sd_bus_vtable>& vtable )
 {
-    // Tell, don't ask
-    auto slot = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
-    interfaceData.slot_.reset(slot);
-    interfaceData.slot_.get_deleter() = [this](sd_bus_slot *slot){ connection_.removeObjectVTable(slot); };
+    interfaceData.slot = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
+}
+
+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)
@@ -237,15 +315,15 @@ int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData,
     auto* object = static_cast<Object*>(userData);
     assert(object != nullptr);
 
-    MethodCall message{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_;
+    auto& callback = object->interfaces_[message.getInterfaceName()].methods[message.getMemberName()].callback;
     assert(callback);
 
     try
     {
-        callback(message);
+        callback(std::move(message));
     }
     catch (const sdbus::Error& e)
     {
@@ -267,7 +345,7 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/
     assert(object != nullptr);
 
     // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[interface].properties_[property].getCallback_;
+    auto& callback = object->interfaces_[interface].properties[property].getCallback;
     // Getter can be empty - the case of "write-only" property
     if (!callback)
     {
@@ -275,7 +353,7 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/
         return 1;
     }
 
-    Message reply{sdbusReply, &object->connection_.getSdBusInterface()};
+    auto reply = Message::Factory::create<PropertyGetReply>(sdbusReply, &object->connection_.getSdBusInterface());
 
     try
     {
@@ -301,10 +379,10 @@ int Object::sdbus_property_set_callback( sd_bus */*bus*/
     assert(object != nullptr);
 
     // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[interface].properties_[property].setCallback_;
+    auto& callback = object->interfaces_[interface].properties[property].setCallback;
     assert(callback);
 
-    Message value{sdbusValue, &object->connection_.getSdBusInterface()};
+    auto value = Message::Factory::create<PropertySetCall>(sdbusValue, &object->connection_.getSdBusInterface());
 
     try
     {
@@ -318,7 +396,7 @@ int Object::sdbus_property_set_callback( sd_bus */*bus*/
     return 1;
 }
 
-}}
+}
 
 namespace sdbus {
 

src/Object.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Object.h
  *
@@ -36,8 +37,7 @@
 #include <memory>
 #include <cassert>
 
-namespace sdbus {
-namespace internal {
+namespace sdbus::internal {
 
     class Object
         : public IObject
@@ -46,33 +46,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 registerMethod( const std::string& interfaceName
-                           , const std::string& methodName
-                           , const std::string& inputSignature
-                           , const std::string& outputSignature
-                           , async_method_callback asyncMethodCallback
-                           , 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;
@@ -80,9 +85,23 @@ namespace internal {
         void setInterfaceFlags(const std::string& interfaceName, Flags flags) override;
 
         void finishRegistration() override;
+        void unregister() override;
 
         sdbus::Signal createSignal(const std::string& interfaceName, const std::string& signalName) override;
         void emitSignal(const sdbus::Signal& message) override;
+        void emitPropertiesChangedSignal(const std::string& interfaceName, const std::vector<std::string>& propNames) override;
+        void emitPropertiesChangedSignal(const std::string& interfaceName) override;
+        void emitInterfacesAddedSignal() override;
+        void emitInterfacesAddedSignal(const std::vector<std::string>& interfaces) override;
+        void emitInterfacesRemovedSignal() override;
+        void emitInterfacesRemovedSignal(const std::vector<std::string>& interfaces) override;
+
+        void addObjectManager() override;
+        void removeObjectManager() override;
+        bool hasObjectManager() const override;
+
+        sdbus::IConnection& getConnection() const override;
+        const std::string& getObjectPath() const override;
 
     private:
         using InterfaceName = std::string;
@@ -91,32 +110,34 @@ namespace internal {
             using MethodName = std::string;
             struct MethodData
             {
-                std::string inputArgs_;
-                std::string outputArgs_;
-                std::function<void(MethodCall&)> callback_;
+                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;
 
-            std::unique_ptr<sd_bus_slot, std::function<void(sd_bus_slot*)>> slot_;
+            SlotPtr slot;
         };
 
         static const std::vector<sd_bus_vtable>& createInterfaceVTable(InterfaceData& interfaceData);
@@ -126,6 +147,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
@@ -147,9 +169,9 @@ namespace internal {
         sdbus::internal::IConnection& connection_;
         std::string objectPath_;
         std::map<InterfaceName, InterfaceData> interfaces_;
+        SlotPtr objectManagerSlot_;
     };
 
 }
-}
 
 #endif /* SDBUS_CXX_INTERNAL_OBJECT_H_ */

src/ObjectProxy.cpp

@@ -1,205 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file ObjectProxy.cpp
- *
- * Created on: Nov 8, 2016
- * 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 "ObjectProxy.h"
-#include <sdbus-c++/Message.h>
-#include <sdbus-c++/IConnection.h>
-#include <sdbus-c++/Error.h>
-#include "IConnection.h"
-#include <systemd/sd-bus.h>
-#include <cassert>
-#include <chrono>
-#include <thread>
-
-namespace sdbus { namespace internal {
-
-ObjectProxy::ObjectProxy(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))
-{
-    // The connection is not ours only, it is managed by the client and we just reference it here,
-    // so we expect the client to manage the event loop upon this connection themselves.
-}
-
-ObjectProxy::ObjectProxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
-                        , std::string destination
-                        , std::string objectPath )
-    : connection_(std::move(connection))
-    , destination_(std::move(destination))
-    , objectPath_(std::move(objectPath))
-{
-    // The connection is ours only, so we have to manage event loop upon this connection,
-    // so we get signals, async replies, and other messages from D-Bus.
-    connection_->enterProcessingLoopAsync();
-}
-
-MethodCall ObjectProxy::createMethodCall(const std::string& interfaceName, const std::string& methodName)
-{
-    return connection_->createMethodCall(destination_, objectPath_, interfaceName, methodName);
-}
-
-AsyncMethodCall ObjectProxy::createAsyncMethodCall(const std::string& interfaceName, const std::string& methodName)
-{
-    return AsyncMethodCall{ObjectProxy::createMethodCall(interfaceName, methodName)};
-}
-
-MethodReply ObjectProxy::callMethod(const MethodCall& message)
-{
-    return message.send();
-}
-
-void ObjectProxy::callMethod(const AsyncMethodCall& message, async_reply_handler asyncReplyCallback)
-{
-    auto callback = (void*)&ObjectProxy::sdbus_async_reply_handler;
-    // Allocated userData gets deleted in the sdbus_async_reply_handler
-    auto userData = new AsyncReplyUserData{*this, std::move(asyncReplyCallback)};
-
-    message.send(callback, userData);
-}
-
-void ObjectProxy::registerSignalHandler( const std::string& interfaceName
-                                       , const std::string& signalName
-                                       , signal_handler signalHandler )
-{
-    SDBUS_THROW_ERROR_IF(!signalHandler, "Invalid signal handler provided", EINVAL);
-
-    auto& interface = interfaces_[interfaceName];
-
-    InterfaceData::SignalData signalData{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 ObjectProxy::finishRegistration()
-{
-    registerSignalHandlers(*connection_);
-}
-
-void ObjectProxy::registerSignalHandlers(sdbus::internal::IConnection& connection)
-{
-    for (auto& interfaceItem : interfaces_)
-    {
-        const auto& interfaceName = interfaceItem.first;
-        auto& signalsOnInterface = interfaceItem.second.signals_;
-
-        for (auto& signalItem : signalsOnInterface)
-        {
-            const auto& signalName = signalItem.first;
-            auto& slot = signalItem.second.slot_;
-            auto* rawSlotPtr = connection.registerSignalHandler( objectPath_
-                                                               , interfaceName
-                                                               , signalName
-                                                               , &ObjectProxy::sdbus_signal_callback
-                                                               , this );
-            slot.reset(rawSlotPtr);
-            slot.get_deleter() = [&connection](sd_bus_slot *slot){ connection.unregisterSignalHandler(slot); };
-        }
-    }
-}
-
-int ObjectProxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
-{
-    // We are assuming the ownership of the async reply handler pointer passed here
-    std::unique_ptr<AsyncReplyUserData> asyncReplyUserData{static_cast<AsyncReplyUserData*>(userData)};
-    assert(asyncReplyUserData != nullptr);
-    assert(asyncReplyUserData->callback);
-
-    MethodReply message{sdbusMessage, &asyncReplyUserData->proxy.connection_->getSdBusInterface()};
-
-    const auto* error = sd_bus_message_get_error(sdbusMessage);
-    if (error == nullptr)
-    {
-        asyncReplyUserData->callback(message, nullptr);
-    }
-    else
-    {
-        sdbus::Error exception(error->name, error->message);
-        asyncReplyUserData->callback(message, &exception);
-    }
-}
-
-int ObjectProxy::sdbus_signal_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
-{
-    auto* proxy = static_cast<ObjectProxy*>(userData);
-    assert(proxy != nullptr);
-
-    Signal message{sdbusMessage, &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);
-
-    callback(message);
-
-    return 1;
-}
-
-}}
-
-namespace sdbus {
-
-std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( IConnection& connection
-                                                      , std::string destination
-                                                      , std::string objectPath )
-{
-    auto* sdbusConnection = dynamic_cast<sdbus::internal::IConnection*>(&connection);
-    SDBUS_THROW_ERROR_IF(!sdbusConnection, "Connection is not a real sdbus-c++ connection", EINVAL);
-
-    return std::make_unique<sdbus::internal::ObjectProxy>( *sdbusConnection
-                                                         , std::move(destination)
-                                                         , std::move(objectPath) );
-}
-
-std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( std::unique_ptr<IConnection>&& connection
-                                                      , std::string destination
-                                                      , std::string objectPath )
-{
-    auto* sdbusConnection = dynamic_cast<sdbus::internal::IConnection*>(connection.get());
-    SDBUS_THROW_ERROR_IF(!sdbusConnection, "Connection is not a real sdbus-c++ connection", EINVAL);
-
-    connection.release();
-
-    return std::make_unique<sdbus::internal::ObjectProxy>( std::unique_ptr<sdbus::internal::IConnection>(sdbusConnection)
-                                                         , std::move(destination)
-                                                         , std::move(objectPath) );
-}
-
-std::unique_ptr<sdbus::IObjectProxy> createObjectProxy( std::string destination
-                                                      , std::string objectPath )
-{
-    auto connection = sdbus::createConnection();
-
-    auto sdbusConnection = std::unique_ptr<sdbus::internal::IConnection>(dynamic_cast<sdbus::internal::IConnection*>(connection.release()));
-    assert(sdbusConnection != nullptr);
-
-    return std::make_unique<sdbus::internal::ObjectProxy>( std::move(sdbusConnection)
-                                                         , std::move(destination)
-                                                         , std::move(objectPath) );
-}
-
-}

src/ObjectProxy.h

@@ -1,98 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file ObjectProxy.h
- *
- * Created on: Nov 8, 2016
- * 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_OBJECTPROXY_H_
-#define SDBUS_CXX_INTERNAL_OBJECTPROXY_H_
-
-#include <sdbus-c++/IObjectProxy.h>
-#include <systemd/sd-bus.h>
-#include <string>
-#include <memory>
-#include <map>
-
-// Forward declarations
-namespace sdbus { namespace internal {
-    class IConnection;
-}}
-
-namespace sdbus {
-namespace internal {
-
-    class ObjectProxy
-        : public IObjectProxy
-    {
-    public:
-        ObjectProxy( sdbus::internal::IConnection& connection
-                   , std::string destination
-                   , std::string objectPath );
-        ObjectProxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
-                   , std::string destination
-                   , std::string objectPath );
-
-        MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) override;
-        AsyncMethodCall createAsyncMethodCall(const std::string& interfaceName, const std::string& methodName) override;
-        MethodReply callMethod(const MethodCall& message) override;
-        void callMethod(const AsyncMethodCall& message, async_reply_handler asyncReplyCallback) override;
-
-        void registerSignalHandler( const std::string& interfaceName
-                                  , const std::string& signalName
-                                  , signal_handler signalHandler ) override;
-        void finishRegistration() override;
-
-    private:
-        struct AsyncReplyUserData
-        {
-            ObjectProxy& proxy;
-            async_reply_handler callback;
-        };
-
-        void registerSignalHandlers(sdbus::internal::IConnection& connection);
-        static int sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
-        static int sdbus_signal_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
-
-    private:
-        std::unique_ptr< sdbus::internal::IConnection
-                       , std::function<void(sdbus::internal::IConnection*)>
-                       > connection_;
-        std::string destination_;
-        std::string objectPath_;
-
-        using InterfaceName = std::string;
-        struct InterfaceData
-        {
-            using SignalName = std::string;
-            struct SignalData
-            {
-                signal_handler callback_;
-                std::unique_ptr<sd_bus_slot, std::function<void(sd_bus_slot*)>> slot_;
-            };
-            std::map<SignalName, SignalData> signals_;
-        };
-        std::map<InterfaceName, InterfaceData> interfaces_;
-    };
-
-}}
-
-#endif /* SDBUS_CXX_INTERNAL_OBJECTPROXY_H_ */

src/Proxy.cpp

@@ -0,0 +1,327 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file Proxy.cpp
+ *
+ * Created on: Nov 8, 2016
+ * 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 "Proxy.h"
+#include "IConnection.h"
+#include "MessageUtils.h"
+#include "sdbus-c++/Message.h"
+#include "sdbus-c++/IConnection.h"
+#include "sdbus-c++/Error.h"
+#include "ScopeGuard.h"
+#include <systemd/sd-bus.h>
+#include <cassert>
+#include <chrono>
+#include <thread>
+
+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))
+{
+    // 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.
+}
+
+Proxy::Proxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
+            , std::string destination
+            , std::string objectPath )
+    : connection_(std::move(connection))
+    , destination_(std::move(destination))
+    , objectPath_(std::move(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_->enterEventLoopAsync();
+}
+
+MethodCall Proxy::createMethodCall(const std::string& interfaceName, const std::string& methodName)
+{
+    return connection_->createMethodCall(destination_, objectPath_, interfaceName, methodName);
+}
+
+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
+    // 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.
+    // 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);
+
+    // If we don't need to wait for any reply, we can send the message now irrespective of the context
+    if (message.doesntExpectReply())
+        return message.send(timeout);
+
+    // If we are in the context of event loop thread, we can send the D-Bus call synchronously
+    // and wait blockingly for the reply, because we are the exclusive listeners on the socket
+    auto reply = connection_->tryCallMethodSynchronously(message, timeout);
+    if (reply.isValid())
+        return reply;
+
+    // Otherwise we send the call asynchronously and do blocking wait for the reply from the event loop thread
+    return sendMethodCallMessageAndWaitForReply(message, 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_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);
+
+    auto slotPtr = callData->slot.get();
+    pendingAsyncCalls_.addCall(slotPtr, std::move(callData));
+
+    return {weakData};
+}
+
+MethodReply Proxy::sendMethodCallMessageAndWaitForReply(const MethodCall& message, uint64_t timeout)
+{
+    /*thread_local*/ SyncCallReplyData syncCallReplyData;
+
+    async_reply_handler asyncReplyCallback = [&syncCallReplyData](MethodReply& reply, const Error* error)
+    {
+        syncCallReplyData.sendMethodReplyToWaitingThread(reply, error);
+    };
+    auto callback = (void*)&Proxy::sdbus_async_reply_handler;
+    AsyncCalls::CallData callData{*this, std::move(asyncReplyCallback), {}};
+
+    message.send(callback, &callData, timeout, dont_request_slot);
+
+    return syncCallReplyData.waitForMethodReply();
+}
+
+void Proxy::SyncCallReplyData::sendMethodReplyToWaitingThread(MethodReply& reply, const Error* error)
+{
+    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
+
+    if (error == nullptr)
+        reply_ = std::move(reply);
+    else
+        error_ = std::make_unique<Error>(*error);
+}
+
+MethodReply Proxy::SyncCallReplyData::waitForMethodReply()
+{
+    std::unique_lock lock{mutex_};
+    cond_.wait(lock, [this](){ return arrived_; });
+
+    //arrived_ = false; // Necessary if SyncCallReplyData instance is thread_local
+
+    if (error_)
+        throw *error_;
+
+    return std::move(reply_);
+}
+
+void Proxy::registerSignalHandler( const std::string& interfaceName
+                                 , const std::string& signalName
+                                 , signal_handler signalHandler )
+{
+    SDBUS_THROW_ERROR_IF(!signalHandler, "Invalid signal handler provided", EINVAL);
+
+    auto& interface = interfaces_[interfaceName];
+
+    InterfaceData::SignalData signalData{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::finishRegistration()
+{
+    registerSignalHandlers(*connection_);
+}
+
+void Proxy::registerSignalHandlers(sdbus::internal::IConnection& connection)
+{
+    for (auto& interfaceItem : interfaces_)
+    {
+        const auto& interfaceName = interfaceItem.first;
+        auto& signalsOnInterface = interfaceItem.second.signals_;
+
+        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 );
+        }
+    }
+}
+
+void Proxy::unregister()
+{
+    pendingAsyncCalls_.clear();
+    interfaces_.clear();
+}
+
+const std::string& Proxy::getObjectPath() const
+{
+    return objectPath_;
+}
+
+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
+    {
+        // 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)
+    {
+        asyncCallData->callback(message, nullptr);
+    }
+    else
+    {
+        sdbus::Error exception(error->name, error->message);
+        asyncCallData->callback(message, &exception);
+    }
+
+    return 1;
+}
+
+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 message = Message::Factory::create<Signal>(sdbusMessage, &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);
+
+    callback(message);
+
+    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 {
+
+std::unique_ptr<sdbus::IProxy> createProxy( IConnection& connection
+                                          , std::string destination
+                                          , std::string objectPath )
+{
+    auto* sdbusConnection = dynamic_cast<sdbus::internal::IConnection*>(&connection);
+    SDBUS_THROW_ERROR_IF(!sdbusConnection, "Connection is not a real sdbus-c++ connection", EINVAL);
+
+    return std::make_unique<sdbus::internal::Proxy>( *sdbusConnection
+                                                   , std::move(destination)
+                                                   , std::move(objectPath) );
+}
+
+std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<IConnection>&& connection
+                                          , std::string destination
+                                          , std::string objectPath )
+{
+    auto* sdbusConnection = dynamic_cast<sdbus::internal::IConnection*>(connection.get());
+    SDBUS_THROW_ERROR_IF(!sdbusConnection, "Connection is not a real sdbus-c++ connection", EINVAL);
+
+    connection.release();
+
+    return std::make_unique<sdbus::internal::Proxy>( std::unique_ptr<sdbus::internal::IConnection>(sdbusConnection)
+                                                   , std::move(destination)
+                                                   , std::move(objectPath) );
+}
+
+std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
+                                          , std::string objectPath )
+{
+    auto connection = sdbus::createConnection();
+
+    auto sdbusConnection = std::unique_ptr<sdbus::internal::IConnection>(dynamic_cast<sdbus::internal::IConnection*>(connection.release()));
+    assert(sdbusConnection != nullptr);
+
+    return std::make_unique<sdbus::internal::Proxy>( std::move(sdbusConnection)
+                                                   , std::move(destination)
+                                                   , std::move(objectPath) );
+}
+
+}

src/Proxy.h

@@ -0,0 +1,168 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file Proxy.h
+ *
+ * Created on: Nov 8, 2016
+ * 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_PROXY_H_
+#define SDBUS_CXX_INTERNAL_PROXY_H_
+
+#include <sdbus-c++/IProxy.h>
+#include "IConnection.h"
+#include <systemd/sd-bus.h>
+#include <string>
+#include <memory>
+#include <map>
+#include <unordered_map>
+#include <mutex>
+#include <condition_variable>
+
+namespace sdbus::internal {
+
+    class Proxy
+        : public IProxy
+    {
+    public:
+        Proxy( sdbus::internal::IConnection& connection
+             , std::string destination
+             , std::string objectPath );
+        Proxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
+             , std::string destination
+             , std::string objectPath );
+
+        MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) override;
+        MethodReply callMethod(const MethodCall& message, 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 finishRegistration() override;
+        void unregister() override;
+
+        const std::string& getObjectPath() const override;
+
+    private:
+        class SyncCallReplyData
+        {
+        public:
+            void sendMethodReplyToWaitingThread(MethodReply& reply, const Error* error);
+            MethodReply waitForMethodReply();
+
+        private:
+            std::mutex mutex_;
+            std::condition_variable cond_;
+            bool arrived_{};
+            MethodReply reply_;
+            std::unique_ptr<Error> error_;
+        };
+
+        MethodReply sendMethodCallMessageAndWaitForReply(const MethodCall& message, uint64_t timeout);
+        void registerSignalHandlers(sdbus::internal::IConnection& connection);
+        static int sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
+        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_;
+        std::string destination_;
+        std::string objectPath_;
+
+        using InterfaceName = std::string;
+        struct InterfaceData
+        {
+            using SignalName = std::string;
+            struct SignalData
+            {
+                signal_handler callback_;
+                SlotPtr slot_;
+            };
+            std::map<SignalName, SignalData> signals_;
+        };
+        std::map<InterfaceName, InterfaceData> interfaces_;
+
+        // We need to keep track of pending async calls. When the proxy is being destructed, we must
+        // remove all slots of these pending calls, otherwise in case when the connection outlives
+        // the proxy, we might get async reply handlers invoked for pending async calls after the proxy
+        // has been destroyed, which is a free ticket into the realm of undefined behavior.
+        class AsyncCalls
+        {
+        public:
+            struct CallData
+            {
+                Proxy& proxy;
+                async_reply_handler callback;
+                MethodCall::Slot slot;
+            };
+
+            ~AsyncCalls()
+            {
+                clear();
+            }
+
+            bool addCall(void* slot, std::shared_ptr<CallData> asyncCallData)
+            {
+                std::lock_guard lock(mutex_);
+                return calls_.emplace(slot, std::move(asyncCallData)).second;
+            }
+
+            void removeCall(void* slot)
+            {
+                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 lock(mutex_);
+                auto asyncCallSlots = std::move(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::shared_ptr<CallData>> calls_;
+            std::mutex mutex_;
+        } pendingAsyncCalls_;
+    };
+
+}
+
+#endif /* SDBUS_CXX_INTERNAL_PROXY_H_ */

src/ScopeGuard.h

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

src/SdBus.cpp

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file SdBus.cpp
  * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@@ -25,72 +26,141 @@
  */
 
 #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);
 }
 
+int SdBus::sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec)
+{
+#if LIBSYSTEMD_VERSION>=240
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_set_method_call_timeout(bus, usec);
+#else
+    (void)bus;
+    (void)usec;
+    throw sdbus::Error(SD_BUS_ERROR_NOT_SUPPORTED, "Setting general method call timeout not supported by underlying version of libsystemd");
+#endif
+}
+
+int SdBus::sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret)
+{
+#if LIBSYSTEMD_VERSION>=240
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_get_method_call_timeout(bus, ret);
+#else
+    (void)bus;
+    (void)ret;
+    throw sdbus::Error(SD_BUS_ERROR_NOT_SUPPORTED, "Getting general method call timeout not supported by underlying version of libsystemd");
+#endif
+}
+
+int SdBus::sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names)
+{
+    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::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::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::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::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_emit_interfaces_removed_strv(bus, path, interfaces);
+}
+
 int SdBus::sd_bus_open_user(sd_bus **ret)
 {
     return ::sd_bus_open_user(ret);
@@ -101,51 +171,69 @@ int SdBus::sd_bus_open_system(sd_bus **ret)
     return ::sd_bus_open_system(ret);
 }
 
+int SdBus::sd_bus_open_system_remote(sd_bus **ret, const char *host)
+{
+    return ::sd_bus_open_system_remote(ret, 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::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::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_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)
@@ -172,4 +260,4 @@ sd_bus* SdBus::sd_bus_flush_close_unref(sd_bus *bus)
     return ::sd_bus_flush_close_unref(bus);
 }
 
-}}
+}

src/SdBus.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file SdBus.h
  * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
@@ -30,7 +31,7 @@
 #include "ISdBus.h"
 #include <mutex>
 
-namespace sdbus { namespace internal {
+namespace sdbus::internal {
 
 class SdBus final : public ISdBus
 {
@@ -42,16 +43,29 @@ 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;
     virtual int sd_bus_message_new_method_error(sd_bus_message *call, sd_bus_message **m, const sd_bus_error *e) override;
 
+    virtual int sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec) override;
+    virtual int sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret) override;
+
+    virtual int sd_bus_emit_properties_changed_strv(sd_bus *bus, const char *path, const char *interface, char **names) override;
+    virtual int sd_bus_emit_object_added(sd_bus *bus, const char *path) override;
+    virtual int sd_bus_emit_object_removed(sd_bus *bus, const char *path) override;
+    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_system(sd_bus **ret) 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;
+    virtual int sd_bus_get_unique_name(sd_bus *bus, const char **name) override;
     virtual int sd_bus_add_object_vtable(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata) override;
+    virtual int sd_bus_add_object_manager(sd_bus *bus, sd_bus_slot **slot, const char *path) override;
     virtual int sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata) override;
     virtual sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) override;
 
@@ -65,6 +79,6 @@ private:
     std::recursive_mutex sdbusMutex_;
 };
 
-}}
+}
 
 #endif //SDBUS_C_SDBUS_H

src/Types.cpp

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

src/VTableUtils.c

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file VTableUtils.c
  *
@@ -35,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,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file VTableUtils.h
  *
@@ -37,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

test/CMakeLists.txt

@@ -1,148 +0,0 @@
-#-------------------------------
-# 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)
-
-execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
-    RESULT_VARIABLE result
-    WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download)
-
-if(result)
-    message(FATAL_ERROR "CMake step for googletest failed: ${result}")
-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 BOOL "" FORCE)
-
-add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
-    ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
-    EXCLUDE_FROM_ALL)
-
-#-------------------------------
-# SOURCE FILES CONFIGURATION
-#-------------------------------
-
-set(UNITTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/unittests)
-set(UNITTESTS_SRCS
-    ${UNITTESTS_SOURCE_DIR}/libsdbus-c++_unittests.cpp
-    ${UNITTESTS_SOURCE_DIR}/Message_test.cpp
-    ${UNITTESTS_SOURCE_DIR}/Types_test.cpp
-    ${UNITTESTS_SOURCE_DIR}/TypeTraits_test.cpp
-    ${UNITTESTS_SOURCE_DIR}/Connection_test.cpp
-    ${UNITTESTS_SOURCE_DIR}/mocks/SdBusMock.h)
-
-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}/libsdbus-c++_integrationtests.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)
-
-set(PERFTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/perftests)
-set(STRESSTESTS_CLIENT_SRCS
-    ${PERFTESTS_SOURCE_DIR}/client.cpp
-    ${PERFTESTS_SOURCE_DIR}/perftest-proxy.h)
-set(STRESSTESTS_SERVER_SRCS
-    ${PERFTESTS_SOURCE_DIR}/server.cpp
-    ${PERFTESTS_SOURCE_DIR}/perftest-adaptor.h)
-
-set(STRESSTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/stresstests)
-set(STRESSTESTS_SRCS
-    ${STRESSTESTS_SOURCE_DIR}/stresstests.cpp
-    ${STRESSTESTS_SOURCE_DIR}/fahrenheit-thermometer-adaptor.h
-    ${STRESSTESTS_SOURCE_DIR}/fahrenheit-thermometer-proxy.h
-    ${STRESSTESTS_SOURCE_DIR}/concatenator-adaptor.h
-    ${STRESSTESTS_SOURCE_DIR}/concatenator-proxy.h)
-
-#-------------------------------
-# GENERAL COMPILER CONFIGURATION
-#-------------------------------
-
-include_directories(${CMAKE_CURRENT_SOURCE_DIR})
-
-#----------------------------------
-# BUILD INFORMATION
-#----------------------------------
-
-# Turn off -isystem gcc option that CMake uses for imported
-# targets even when INTERFACE_INCLUDE_DIRECTORIES is used.
-set(CMAKE_NO_SYSTEM_FROM_IMPORTED "1")
-
-add_executable(libsdbus-c++_unittests ${UNITTESTS_SRCS} $<TARGET_OBJECTS:sdbuscppobjects>)
-target_link_libraries(libsdbus-c++_unittests ${SYSTEMD_LIBRARIES} gmock gmock_main)
-
-add_executable(libsdbus-c++_integrationtests ${INTEGRATIONTESTS_SRCS})
-target_link_libraries(libsdbus-c++_integrationtests sdbus-c++ gmock gmock_main)
-
-# Manual performance tests
-option(ENABLE_PERFTESTS "Build and install manual performance tests (default OFF)" OFF)
-if(ENABLE_PERFTESTS)
-    add_executable(libsdbus-c++_perftests_client ${STRESSTESTS_CLIENT_SRCS})
-    target_link_libraries(libsdbus-c++_perftests_client sdbus-c++)
-    add_executable(libsdbus-c++_perftests_server ${STRESSTESTS_SERVER_SRCS})
-    target_link_libraries(libsdbus-c++_perftests_server sdbus-c++)
-endif()
-
-# Manual stress tests
-option(ENABLE_STRESSTESTS "Build and install manual stress tests (default OFF)" ON)
-if(ENABLE_STRESSTESTS)
-    set(THREADS_PREFER_PTHREAD_FLAG ON)
-    find_package(Threads REQUIRED)
-
-    add_executable(sdbus-c++-stress-tests ${STRESSTESTS_SRCS})
-    target_link_libraries(sdbus-c++-stress-tests sdbus-c++ Threads::Threads)
-endif()
-
-#----------------------------------
-# INSTALLATION
-#----------------------------------
-
-install(TARGETS libsdbus-c++_unittests DESTINATION /opt/test/bin)
-install(TARGETS libsdbus-c++_integrationtests DESTINATION /opt/test/bin)
-install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/libsdbus-cpp-test.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
-
-if(ENABLE_PERFTESTS)
-    install(TARGETS libsdbus-c++_perftests_client DESTINATION /opt/test/bin)
-    install(TARGETS libsdbus-c++_perftests_server DESTINATION /opt/test/bin)
-    install(FILES perftests/files/org.sdbuscpp.perftest.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
-endif()
-
-if(ENABLE_STRESSTESTS)
-    install(TARGETS sdbus-c++-stress-tests DESTINATION /opt/test/bin)
-    install(FILES perftests/files/org.sdbuscpp.stresstest.conf DESTINATION ${CMAKE_INSTALL_SYSCONFDIR}/dbus-1/system.d)
-endif()
-
-#----------------------------------
-# RUNNING THE TESTS UPON BUILD
-#----------------------------------
-
-if(CMAKE_CROSSCOMPILING)
-    if(NOT DEFINED UNIT_TESTS_RUNNER)
-        set(UNIT_TESTS_RUNNER $ENV{UNIT_TESTS_RUNNER})
-    endif()
-    if(NOT DEFINED TEST_DEVICE_IP)
-        set(TEST_DEVICE_IP $ENV{TEST_DEVICE_IP})
-    endif()
-
-    if(NOT (UNIT_TESTS_RUNNER AND TEST_DEVICE_IP))
-        message(WARNING "UNIT_TESTS_RUNNER and TEST_DEVICE_IP variables must be defined to run tests remotely")
-    endif()
-    add_test(NAME libsdbus-c++_unittests COMMAND ${UNIT_TESTS_RUNNER} --deviceip=${TEST_DEVICE_IP} --testbin=libsdbus-c++_unittests)
-    add_test(NAME libsdbus-c++_integrationtests COMMAND ${UNIT_TESTS_RUNNER} --deviceip=${TEST_DEVICE_IP} --testbin=libsdbus-c++_integrationtests)
-else()
-    add_test(NAME libsdbus-c++_unittests COMMAND libsdbus-c++_unittests)
-    add_test(NAME libsdbus-c++_integrationtests COMMAND libsdbus-c++_integrationtests)
-endif() 

test/integrationtests/AdaptorAndProxy_test.cpp

@@ -1,428 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @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 "Connection.h"
-#include "SdBus.h"
-
-#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>
-
-using ::testing::Eq;
-using ::testing::Gt;
-using ::testing::ElementsAre;
-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);
-    }
-
-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, CallsMethodWithComplexTypeSuccesfully)
-{
-    auto resComplex = m_proxy->getComplex();
-    ASSERT_THAT(resComplex.count(0), Eq(1));
-}
-
-TEST_F(SdbusTestObject, CallsMultiplyMethodWithNoReplyFlag)
-{
-    m_proxy->multiplyWithNoReply(INT64_VALUE, DOUBLE_VALUE);
-
-    for (auto i = 0; i < 100; ++i)
-    {
-        if (m_adaptor->wasMultiplyCalled())
-            break;
-        std::this_thread::sleep_for(10ms);
-    }
-    ASSERT_TRUE(m_adaptor->wasMultiplyCalled());
-    ASSERT_THAT(m_adaptor->getMultiplyResult(), Eq(INT64_VALUE * DOUBLE_VALUE));
-}
-
-TEST_F(SdbusTestObject, CallsMethodThatThrowsError)
-{
-    try
-    {
-        m_proxy->throwError();
-        FAIL() << "Expected sdbus::Error exception";
-    }
-    catch (const sdbus::Error& e)
-    {
-        ASSERT_THAT(e.getName(), Eq("org.freedesktop.DBus.Error.AccessDenied"));
-        ASSERT_THAT(e.getMessage(), Eq("A test error occurred (Operation not permitted)"));
-    }
-    catch(...)
-    {
-        FAIL() << "Expected sdbus::Error exception";
-    }
-}
-
-TEST_F(SdbusTestObject, CallsErrorThrowingMethodWithDontExpectReplySet)
-{
-    ASSERT_NO_THROW(m_proxy->throwErrorWithNoReply());
-
-    for (auto i = 0; i < 100; ++i)
-    {
-        if (m_adaptor->wasThrowErrorCalled())
-            break;
-        std::this_thread::sleep_for(10ms);
-    }
-    ASSERT_TRUE(m_adaptor->wasThrowErrorCalled());
-}
-
-TEST_F(SdbusTestObject, 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);
-}
-
-// Signals
-
-TEST_F(SdbusTestObject, EmitsSimpleSignalSuccesfully)
-{
-    auto count = m_proxy->getSimpleCallCount();
-    m_adaptor->simpleSignal();
-    usleep(10000);
-
-    ASSERT_THAT(m_proxy->getSimpleCallCount(), Eq(count + 1));
-}
-
-TEST_F(SdbusTestObject, EmitsSignalWithMapSuccesfully)
-{
-    m_adaptor->signalWithMap({{0, "zero"}, {1, "one"}});
-    usleep(10000);
-
-    auto map = m_proxy->getMap();
-    ASSERT_THAT(map[0], Eq("zero"));
-    ASSERT_THAT(map[1], Eq("one"));
-}
-
-TEST_F(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
-{
-    double d = 3.14;
-    m_adaptor->signalWithVariant(3.14);
-    usleep(10000);
-
-    ASSERT_THAT(m_proxy->getVariantValue(), d);
-}
-
-TEST_F(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
-{
-    m_adaptor->signalWithoutRegistration({"platform", {"av"}});
-    usleep(10000);
-
-    auto signature = m_proxy->getSignatureFromSignal();
-    ASSERT_THAT(signature["platform"], Eq("av"));
-}
-
-// Properties
-
-TEST_F(SdbusTestObject, ReadsReadPropertySuccesfully)
-{
-    ASSERT_THAT(m_proxy->state(), Eq(STRING_VALUE));
-}
-
-TEST_F(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
-{
-    uint32_t x = 42;
-    ASSERT_NO_THROW(m_proxy->action(x));
-    ASSERT_THAT(m_proxy->action(), Eq(x));
-}
-
-TEST_F(SdbusTestObject, WritesToWritePropertySuccesfully)
-{
-    auto x = true;
-    ASSERT_NO_THROW(m_proxy->blocking(x));
-}
-
-TEST_F(SdbusTestObject, CannotReadFromWriteProperty)
-{
-    ASSERT_THROW(m_proxy->blocking(), sdbus::Error);
-}
-
-TEST_F(SdbusTestObject, AnswersXmlApiDescriptionOnIntrospection)
-{
-    ASSERT_THAT(m_proxy->Introspect(), Eq(m_adaptor->getExpectedXmlApiDescription()));
-}

test/integrationtests/TestingProxy.h

@@ -1,78 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file TestingProxy.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_TESTINGPROXY_H_
-#define SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_
-
-#include "proxy-glue.h"
-
-class TestingProxy : public sdbus::ProxyInterfaces<::testing_proxy, sdbus::introspectable_proxy>
-{
-public:
-    using sdbus::ProxyInterfaces<::testing_proxy, sdbus::introspectable_proxy>::ProxyInterfaces;
-
-    int getSimpleCallCount() const { return m_simpleCallCounter; }
-    std::map<int32_t, std::string> getMap() const { return m_map; }
-    double getVariantValue() const { return m_variantValue; }
-    std::map<std::string, std::string> getSignatureFromSignal() const { return m_signature; }
-
-    void installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler)
-    {
-        m_DoOperationClientSideAsyncReplyHandler = handler;
-    }
-
-protected:
-    void onSimpleSignal() override { ++m_simpleCallCounter; }
-
-    void onSignalWithMap(const std::map<int32_t, std::string>& m) override { m_map = m; }
-
-    void onSignalWithVariant(const sdbus::Variant& v) override
-    {
-        m_variantValue = v.get<double>();
-    }
-
-    void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s) override
-    {
-        m_signature[std::get<0>(s)] = static_cast<std::string>(std::get<0>(std::get<1>(s)));
-    }
-
-    void onDoOperationReply(uint32_t returnValue, const sdbus::Error* error) override
-    {
-        if (m_DoOperationClientSideAsyncReplyHandler)
-            m_DoOperationClientSideAsyncReplyHandler(returnValue, error);
-    }
-
-private:
-    int m_simpleCallCounter{};
-    std::map<int32_t, std::string> m_map;
-    double m_variantValue;
-    std::map<std::string, std::string> m_signature;
-
-    std::function<void(uint32_t res, const sdbus::Error* err)> m_DoOperationClientSideAsyncReplyHandler;
-};
-
-
-
-#endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_ */

test/perftests/perftest-adaptor.h

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

test/perftests/perftest-proxy.h

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

test/stresstests/concatenator-adaptor.h

@@ -1,45 +0,0 @@
-
-/*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
- */
-
-#ifndef __sdbuscpp__concatenator_adaptor_h__adaptor__H__
-#define __sdbuscpp__concatenator_adaptor_h__adaptor__H__
-
-#include <sdbus-c++/sdbus-c++.h>
-#include <string>
-#include <tuple>
-
-namespace org {
-namespace sdbuscpp {
-namespace stresstest {
-
-class concatenator_adaptor
-{
-public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.concatenator";
-
-protected:
-    concatenator_adaptor(sdbus::IObject& object)
-        : object_(object)
-    {
-        object_.registerMethod("concatenate").onInterface(interfaceName).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(interfaceName).withParameters<std::string>();
-    }
-
-public:
-    void concatenatedSignal(const std::string& concatenatedString)
-    {
-        object_.emitSignal("concatenatedSignal").onInterface(interfaceName).withArguments(concatenatedString);
-    }
-
-private:
-    virtual void concatenate(sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params) = 0;
-
-private:
-    sdbus::IObject& object_;
-};
-
-}}} // namespaces
-
-#endif

test/stresstests/concatenator-proxy.h

@@ -1,45 +0,0 @@
-
-/*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
- */
-
-#ifndef __sdbuscpp__concatenator_proxy_h__proxy__H__
-#define __sdbuscpp__concatenator_proxy_h__proxy__H__
-
-#include <sdbus-c++/sdbus-c++.h>
-#include <string>
-#include <tuple>
-
-namespace org {
-namespace sdbuscpp {
-namespace stresstest {
-
-class concatenator_proxy
-{
-public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.concatenator";
-
-protected:
-    concatenator_proxy(sdbus::IObjectProxy& object)
-        : object_(object)
-    {
-        object_.uponSignal("concatenatedSignal").onInterface(interfaceName).call([this](const std::string& concatenatedString){ this->onConcatenatedSignal(concatenatedString); });
-    }
-
-    virtual void onConcatenatedSignal(const std::string& concatenatedString) = 0;
-
-    virtual void onConcatenateReply(const std::string& result, const sdbus::Error* error) = 0;
-
-public:
-    void concatenate(const std::map<std::string, sdbus::Variant>& params)
-    {
-        object_.callMethodAsync("concatenate").onInterface(interfaceName).withArguments(params).uponReplyInvoke([this](const sdbus::Error* error, const std::string& result){ this->onConcatenateReply(result, error); });
-    }
-
-private:
-    sdbus::IObjectProxy& object_;
-};
-
-}}} // namespaces
-
-#endif

test/stresstests/fahrenheit-thermometer-adaptor.h

@@ -1,39 +0,0 @@
-
-/*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
- */
-
-#ifndef __sdbuscpp__fahrenheit_thermometer_adaptor_h__adaptor__H__
-#define __sdbuscpp__fahrenheit_thermometer_adaptor_h__adaptor__H__
-
-#include <sdbus-c++/sdbus-c++.h>
-#include <string>
-#include <tuple>
-
-namespace org {
-namespace sdbuscpp {
-namespace stresstest {
-namespace fahrenheit {
-
-class thermometer_adaptor
-{
-public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.fahrenheit.thermometer";
-
-protected:
-    thermometer_adaptor(sdbus::IObject& object)
-        : object_(object)
-    {
-        object_.registerMethod("getCurrentTemperature").onInterface(interfaceName).implementedAs([this](){ return this->getCurrentTemperature(); });
-    }
-
-private:
-    virtual uint32_t getCurrentTemperature() = 0;
-
-private:
-    sdbus::IObject& object_;
-};
-
-}}}} // namespaces
-
-#endif

test/stresstests/fahrenheit-thermometer-proxy.h

@@ -1,43 +0,0 @@
-
-/*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
- */
-
-#ifndef __sdbuscpp__fahrenheit_thermometer_proxy_h__proxy__H__
-#define __sdbuscpp__fahrenheit_thermometer_proxy_h__proxy__H__
-
-#include <sdbus-c++/sdbus-c++.h>
-#include <string>
-#include <tuple>
-
-namespace org {
-namespace sdbuscpp {
-namespace stresstest {
-namespace fahrenheit {
-
-class thermometer_proxy
-{
-public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.fahrenheit.thermometer";
-
-protected:
-    thermometer_proxy(sdbus::IObjectProxy& object)
-        : object_(object)
-    {
-    }
-
-public:
-    uint32_t getCurrentTemperature()
-    {
-        uint32_t result;
-        object_.callMethod("getCurrentTemperature").onInterface(interfaceName).storeResultsTo(result);
-        return result;
-    }
-
-private:
-    sdbus::IObjectProxy& object_;
-};
-
-}}}} // namespaces
-
-#endif

test/stresstests/org.sdbuscpp.stresstest.fahrenheit.thermometer.xml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-<node name="/org/sdbuscpp/stresstest/fahrenheit/thermometer">
-    <interface name="org.sdbuscpp.stresstest.fahrenheit.thermometer">
-        <method name="getCurrentTemperature">
-            <arg type="u" name="result" direction="out" />
-        </method>
-    </interface>
-</node>

test/stresstests/stresstests.cpp

@@ -1,322 +0,0 @@
-/**
- * (C) 2019 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file stresstests.cpp
- *
- * Created on: Jan 25, 2019
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "celsius-thermometer-adaptor.h"
-#include "celsius-thermometer-proxy.h"
-#include "fahrenheit-thermometer-adaptor.h"
-#include "fahrenheit-thermometer-proxy.h"
-#include "concatenator-adaptor.h"
-#include "concatenator-proxy.h"
-#include <sdbus-c++/sdbus-c++.h>
-#include <vector>
-#include <string>
-#include <iostream>
-#include <unistd.h>
-#include <thread>
-#include <chrono>
-#include <cassert>
-#include <atomic>
-#include <sstream>
-#include <mutex>
-#include <condition_variable>
-#include <queue>
-
-using namespace std::chrono_literals;
-using namespace std::string_literals;
-
-#define SERVICE_1_BUS_NAME "org.sdbuscpp.stresstest.service1"
-#define SERVICE_2_BUS_NAME "org.sdbuscpp.stresstest.service2"
-#define CELSIUS_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstest/celsius/thermometer"
-#define FAHRENHEIT_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstest/fahrenheit/thermometer"
-#define CONCATENATOR_OBJECT_PATH "/org/sdbuscpp/stresstest/concatenator"
-
-class CelsiusThermometerAdaptor : public sdbus::Interfaces<org::sdbuscpp::stresstest::celsius::thermometer_adaptor>
-{
-public:
-    using sdbus::Interfaces<org::sdbuscpp::stresstest::celsius::thermometer_adaptor>::Interfaces;
-
-protected:
-    virtual uint32_t getCurrentTemperature() override
-    {
-        return m_currentTemperature++;
-    }
-
-private:
-    uint32_t m_currentTemperature{};
-};
-
-class CelsiusThermometerProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstest::celsius::thermometer_proxy>
-{
-public:
-    using sdbus::ProxyInterfaces<org::sdbuscpp::stresstest::celsius::thermometer_proxy>::ProxyInterfaces;
-};
-
-class FahrenheitThermometerAdaptor : public sdbus::Interfaces<org::sdbuscpp::stresstest::fahrenheit::thermometer_adaptor>
-{
-public:
-    FahrenheitThermometerAdaptor(sdbus::IConnection& connection, std::string objectPath)
-        : sdbus::Interfaces<org::sdbuscpp::stresstest::fahrenheit::thermometer_adaptor>(connection, std::move(objectPath))
-        , celsiusProxy_(connection, SERVICE_2_BUS_NAME, CELSIUS_THERMOMETER_OBJECT_PATH)
-    {
-    }
-
-protected:
-    virtual uint32_t getCurrentTemperature() override
-    {
-        // In this D-Bus call, make yet another D-Bus call to another service over the same connection
-        return static_cast<uint32_t>(celsiusProxy_.getCurrentTemperature() * 1.8 + 32.);
-    }
-
-private:
-    CelsiusThermometerProxy celsiusProxy_;
-};
-
-class FahrenheitThermometerProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstest::fahrenheit::thermometer_proxy>
-{
-public:
-    using sdbus::ProxyInterfaces<org::sdbuscpp::stresstest::fahrenheit::thermometer_proxy>::ProxyInterfaces;
-};
-
-class ConcatenatorAdaptor : public sdbus::Interfaces<org::sdbuscpp::stresstest::concatenator_adaptor>
-{
-public:
-    ConcatenatorAdaptor(sdbus::IConnection& connection, std::string objectPath)
-        : sdbus::Interfaces<org::sdbuscpp::stresstest::concatenator_adaptor>(connection, std::move(objectPath))
-    {
-        unsigned int workers = std::thread::hardware_concurrency();
-        if (workers < 4)
-            workers = 4;
-
-        for (unsigned int i = 0; i < workers; ++i)
-            workers_.emplace_back([this]()
-            {
-                //std::cout << "Created worker thread 0x" << std::hex << std::this_thread::get_id() << std::dec << std::endl;
-
-                while(!exit_)
-                {
-                    // Pop a work item from the queue
-                    std::unique_lock<std::mutex> lock(mutex_);
-                    cond_.wait(lock, [this]{return !requests_.empty() || exit_;});
-                    if (exit_)
-                        break;
-                    auto request = std::move(requests_.front());
-                    requests_.pop();
-                    lock.unlock();
-
-                    // Do concatenation work, return results and fire signal
-                    auto aString = request.input.at("key1").get<std::string>();
-                    auto aNumber = request.input.at("key2").get<uint32_t>();
-                    auto resultString = aString + " " + std::to_string(aNumber);
-
-                    request.result.returnResults(resultString);
-
-                    concatenatedSignal(resultString);
-                }
-            });
-    }
-
-    ~ConcatenatorAdaptor()
-    {
-        exit_ = true;
-        cond_.notify_all();
-        for (auto& worker : workers_)
-            worker.join();
-    }
-
-protected:
-    virtual void concatenate(sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params) override
-    {
-        std::unique_lock<std::mutex> lock(mutex_);
-        requests_.push(WorkItem{std::move(params), std::move(result)});
-        lock.unlock();
-        cond_.notify_one();
-    }
-
-private:
-    struct WorkItem
-    {
-        std::map<std::string, sdbus::Variant> input;
-        sdbus::Result<std::string> result;
-    };
-    std::mutex mutex_;
-    std::condition_variable cond_;
-    std::queue<WorkItem> requests_;
-    std::vector<std::thread> workers_;
-    std::atomic<bool> exit_{};
-};
-
-class ConcatenatorProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstest::concatenator_proxy>
-{
-public:
-    using sdbus::ProxyInterfaces<org::sdbuscpp::stresstest::concatenator_proxy>::ProxyInterfaces;
-
-private:
-    virtual void onConcatenateReply(const std::string& result, const sdbus::Error* error) override
-    {
-        assert(error == nullptr);
-
-        std::stringstream str(result);
-        std::string aString;
-        str >> aString;
-        assert(aString == "sdbus-c++-stress-tests");
-
-        uint32_t aNumber;
-        str >> aNumber;
-        assert(aNumber >= 0);
-
-        ++repliesReceived_;
-    }
-
-    virtual void onConcatenatedSignal(const std::string& concatenatedString) override
-    {
-        std::stringstream str(concatenatedString);
-        std::string aString;
-        str >> aString;
-        assert(aString == "sdbus-c++-stress-tests");
-
-        uint32_t aNumber;
-        str >> aNumber;
-        assert(aNumber >= 0);
-
-        ++signalsReceived_;
-    }
-
-public:
-    std::atomic<uint32_t> repliesReceived_;
-    std::atomic<uint32_t> signalsReceived_;
-};
-
-//-----------------------------------------
-int main(int /*argc*/, char */*argv*/[])
-{
-    auto service2Connection = sdbus::createSystemBusConnection(SERVICE_2_BUS_NAME);
-    std::thread service2Thread([&con = *service2Connection]()
-    {
-        CelsiusThermometerAdaptor thermometer(con, CELSIUS_THERMOMETER_OBJECT_PATH);
-        con.enterProcessingLoop();
-    });
-
-    auto service1Connection = sdbus::createSystemBusConnection(SERVICE_1_BUS_NAME);
-    std::thread service1Thread([&con = *service1Connection]()
-    {
-        ConcatenatorAdaptor concatenator(con, CONCATENATOR_OBJECT_PATH);
-        FahrenheitThermometerAdaptor thermometer(con, FAHRENHEIT_THERMOMETER_OBJECT_PATH);
-        con.enterProcessingLoop();
-    });
-
-    std::this_thread::sleep_for(100ms);
-
-    std::atomic<uint32_t> concatenationCallsMade{0};
-    std::atomic<uint32_t> concatenationRepliesReceived{0};
-    std::atomic<uint32_t> concatenationSignalsReceived{0};
-    std::atomic<uint32_t> thermometerCallsMade{0};
-
-    auto clientConnection = sdbus::createSystemBusConnection();
-    std::thread clientThread([&, &con = *clientConnection]()
-    {
-        std::atomic<bool> stopClients{false};
-
-        std::thread concatenatorThread([&]()
-        {
-            ConcatenatorProxy concatenator(con, SERVICE_1_BUS_NAME, CONCATENATOR_OBJECT_PATH);
-
-            uint32_t localCounter{};
-
-            // Issue async concatenate calls densely one after another
-            while (!stopClients)
-            {
-                std::map<std::string, sdbus::Variant> param;
-                param["key1"] = "sdbus-c++-stress-tests";
-                param["key2"] = localCounter++;
-
-                concatenator.concatenate(param);
-
-                if ((localCounter % 10) == 0)
-                {
-                    // Make sure the system is catching up with our async requests,
-                    // otherwise sleep a bit to slow down flooding the server.
-                    assert(localCounter >= concatenator.repliesReceived_);
-                    while ((localCounter - concatenator.repliesReceived_) > 20 && !stopClients)
-                        std::this_thread::sleep_for(2ms);
-
-                    // Update statistics
-                    concatenationCallsMade = localCounter;
-                    concatenationRepliesReceived = (uint32_t)concatenator.repliesReceived_;
-                    concatenationSignalsReceived = (uint32_t)concatenator.signalsReceived_;
-                }
-            }
-        });
-
-        std::thread thermometerThread([&]()
-        {
-            FahrenheitThermometerProxy thermometer(con, SERVICE_1_BUS_NAME, FAHRENHEIT_THERMOMETER_OBJECT_PATH);
-            uint32_t localCounter{};
-            uint32_t previousTemperature{};
-
-            while (!stopClients)
-            {
-                localCounter++;
-                auto temperature = thermometer.getCurrentTemperature();
-                assert(temperature >= previousTemperature); // The temperature shall rise continually
-                previousTemperature = temperature;
-                std::this_thread::sleep_for(5ms);
-
-                if ((localCounter % 10) == 0)
-                    thermometerCallsMade = localCounter;
-            }
-        });
-
-        con.enterProcessingLoop();
-
-        stopClients = true;
-        concatenatorThread.join();
-        thermometerThread.join();
-    });
-
-    std::atomic<bool> exitLogger{};
-    std::thread loggerThread([&]()
-    {
-        while (!exitLogger)
-        {
-            std::this_thread::sleep_for(1s);
-
-            std::cout << "Made " << concatenationCallsMade << " concatenation calls, received " << concatenationRepliesReceived << " replies and " << concatenationSignalsReceived << " signals so far." << std::endl;
-            std::cout << "Made " << thermometerCallsMade << " thermometer calls so far." << std::endl << std::endl;
-        }
-    });
-
-    getchar();
-
-    exitLogger = true;
-    loggerThread.join();
-    clientConnection->leaveProcessingLoop();
-    clientThread.join();
-    service1Connection->leaveProcessingLoop();
-    service1Thread.join();
-    service2Connection->leaveProcessingLoop();
-    service2Thread.join();
-    
-    return 0;
-}

test/unittests/Connection_test.cpp

@@ -1,148 +0,0 @@
-/**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
- *
- * @file Connection_test.cpp
- * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
- *
- * Created on: Feb 4, 2019
- * Project: sdbus-c++
- * Description: High-level D-Bus IPC C++ library based on sd-bus
- *
- * This file is part of sdbus-c++.
- *
- * sdbus-c++ is free software; you can redistribute it and/or modify it
- * under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * sdbus-c++ is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "Connection.h"
-#include "unittests/mocks/SdBusMock.h"
-
-#include <gtest/gtest.h>
-
-using ::testing::_;
-using ::testing::DoAll;
-using ::testing::SetArgPointee;
-using ::testing::Return;
-using ::testing::NiceMock;
-
-using BusType = sdbus::internal::Connection::BusType;
-
-
-class ConnectionCreationTest : public ::testing::Test
-{
-protected:
-    ConnectionCreationTest() = default;
-
-    std::unique_ptr<NiceMock<SdBusMock>> mock_ { std::make_unique<NiceMock<SdBusMock>>() };
-    sd_bus* STUB_ { reinterpret_cast<sd_bus*>(1) };
-};
-
-using ASystemBusConnection = ConnectionCreationTest;
-using ASessionBusConnection = ConnectionCreationTest;
-
-TEST_F(ASystemBusConnection, OpensAndFlushesBusWhenCreated)
-{
-    EXPECT_CALL(*mock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(STUB_), Return(1)));
-    EXPECT_CALL(*mock_, sd_bus_flush(_)).Times(1);
-    sdbus::internal::Connection(BusType::eSystem, std::move(mock_));
-}
-
-TEST_F(ASessionBusConnection, OpensAndFlushesBusWhenCreated)
-{
-    EXPECT_CALL(*mock_, sd_bus_open_user(_)).WillOnce(DoAll(SetArgPointee<0>(STUB_), Return(1)));
-    EXPECT_CALL(*mock_, sd_bus_flush(_)).Times(1);
-    sdbus::internal::Connection(BusType::eSession, std::move(mock_));
-}
-
-TEST_F(ASystemBusConnection, ClosesAndUnrefsBusWhenDestructed)
-{
-    ON_CALL(*mock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(1)));
-    EXPECT_CALL(*mock_, sd_bus_flush_close_unref(_)).Times(1);
-    sdbus::internal::Connection(BusType::eSession, std::move(mock_));
-}
-
-TEST_F(ASessionBusConnection, ClosesAndUnrefsBusWhenDestructed)
-{
-    ON_CALL(*mock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(1)));
-    EXPECT_CALL(*mock_, sd_bus_flush_close_unref(_)).Times(1);
-    sdbus::internal::Connection(BusType::eSession, std::move(mock_));
-}
-
-TEST_F(ASystemBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
-{
-    ON_CALL(*mock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(-1)));
-    ASSERT_THROW(sdbus::internal::Connection(BusType::eSystem, std::move(mock_)), sdbus::Error);
-}
-
-TEST_F(ASessionBusConnection, ThrowsErrorWhenOpeningTheBusFailsDuringConstruction)
-{
-    ON_CALL(*mock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(-1)));
-    ASSERT_THROW(sdbus::internal::Connection(BusType::eSession, std::move(mock_)), sdbus::Error);
-}
-
-TEST_F(ASystemBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
-{
-    ON_CALL(*mock_, sd_bus_open_system(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(1)));
-    ON_CALL(*mock_, sd_bus_flush(_)).WillByDefault(Return(-1));
-    ASSERT_THROW(sdbus::internal::Connection(BusType::eSystem, std::move(mock_)), sdbus::Error);
-}
-
-TEST_F(ASessionBusConnection, ThrowsErrorWhenFlushingTheBusFailsDuringConstruction)
-{
-    ON_CALL(*mock_, sd_bus_open_user(_)).WillByDefault(DoAll(SetArgPointee<0>(STUB_), Return(1)));
-    ON_CALL(*mock_, sd_bus_flush(_)).WillByDefault(Return(-1));
-    ASSERT_THROW(sdbus::internal::Connection(BusType::eSession, std::move(mock_)), sdbus::Error);
-}
-
-class ConnectionRequestTest : public ::testing::TestWithParam<BusType>
-{
-protected:
-    ConnectionRequestTest() = default;
-    void SetUp() override
-    {
-        switch (GetParam())
-        {
-            case BusType::eSystem:
-                EXPECT_CALL(*mock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(STUB_), Return(1)));
-                break;
-            case BusType::eSession:
-                EXPECT_CALL(*mock_, sd_bus_open_user(_)).WillOnce(DoAll(SetArgPointee<0>(STUB_), Return(1)));
-                break;
-            default:
-                break;
-        }
-        ON_CALL(*mock_, sd_bus_flush(_)).WillByDefault(Return(1));
-        ON_CALL(*mock_, sd_bus_flush_close_unref(_)).WillByDefault(Return(STUB_));
-    }
-
-    std::unique_ptr<NiceMock<SdBusMock>> mock_ { std::make_unique<NiceMock<SdBusMock>>() };
-    sd_bus* STUB_ { reinterpret_cast<sd_bus*>(1) };
-};
-
-using AConnectionNameRequest = ConnectionRequestTest;
-
-TEST_P(AConnectionNameRequest, DoesNotThrowOnSuccess)
-{
-    EXPECT_CALL(*mock_, sd_bus_request_name(_, _, _)).WillOnce(Return(1));
-    sdbus::internal::Connection(GetParam(), std::move(mock_)).requestName("");
-}
-
-TEST_P(AConnectionNameRequest, ThrowsOnFail)
-{
-    EXPECT_CALL(*mock_, sd_bus_request_name(_, _, _)).WillOnce(Return(-1));
-
-    sdbus::internal::Connection conn_(GetParam(), std::move(mock_));
-    ASSERT_THROW(conn_.requestName(""), sdbus::Error);
-}
-
-INSTANTIATE_TEST_SUITE_P(Request, AConnectionNameRequest, ::testing::Values(BusType::eSystem, BusType::eSession));

tests/CMakeLists.txt

@@ -0,0 +1,136 @@
+#-------------------------------
+# DOWNLOAD AND BUILD OF GOOGLETEST
+#-------------------------------
+
+include(FetchContent)
+
+message("Fetching googletest...")
+FetchContent_Declare(googletest
+                     GIT_REPOSITORY https://github.com/google/googletest.git
+                     GIT_TAG        master
+                     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})
+endif()
+
+#-------------------------------
+# SOURCE FILES CONFIGURATION
+#-------------------------------
+
+set(UNITTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/unittests)
+set(UNITTESTS_SRCS
+    ${UNITTESTS_SOURCE_DIR}/sdbus-c++-unit-tests.cpp
+    ${UNITTESTS_SOURCE_DIR}/Message_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/Types_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/TypeTraits_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/Connection_test.cpp
+    ${UNITTESTS_SOURCE_DIR}/mocks/SdBusMock.h)
+
+set(INTEGRATIONTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/integrationtests)
+set(INTEGRATIONTESTS_SRCS
+    ${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)
+
+set(PERFTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/perftests)
+set(STRESSTESTS_CLIENT_SRCS
+    ${PERFTESTS_SOURCE_DIR}/client.cpp
+    ${PERFTESTS_SOURCE_DIR}/perftests-proxy.h)
+set(STRESSTESTS_SERVER_SRCS
+    ${PERFTESTS_SOURCE_DIR}/server.cpp
+    ${PERFTESTS_SOURCE_DIR}/perftests-adaptor.h)
+
+set(STRESSTESTS_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/stresstests)
+set(STRESSTESTS_SRCS
+    ${STRESSTESTS_SOURCE_DIR}/sdbus-c++-stress-tests.cpp
+    ${STRESSTESTS_SOURCE_DIR}/fahrenheit-thermometer-adaptor.h
+    ${STRESSTESTS_SOURCE_DIR}/fahrenheit-thermometer-proxy.h
+    ${STRESSTESTS_SOURCE_DIR}/celsius-thermometer-adaptor.h
+    ${STRESSTESTS_SOURCE_DIR}/celsius-thermometer-proxy.h
+    ${STRESSTESTS_SOURCE_DIR}/concatenator-adaptor.h
+    ${STRESSTESTS_SOURCE_DIR}/concatenator-proxy.h)
+
+#-------------------------------
+# GENERAL COMPILER CONFIGURATION
+#-------------------------------
+
+include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+
+#----------------------------------
+# BUILD INFORMATION
+#----------------------------------
+
+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 gmock gmock_main)
+
+add_executable(sdbus-c++-integration-tests ${INTEGRATIONTESTS_SRCS})
+target_compile_definitions(sdbus-c++-integration-tests PRIVATE LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
+target_link_libraries(sdbus-c++-integration-tests sdbus-c++ gmock gmock_main)
+
+# Manual performance and stress tests
+option(ENABLE_PERF_TESTS "Build and install manual performance tests (default OFF)" OFF)
+option(ENABLE_STRESS_TESTS "Build and install manual stress tests (default OFF)" OFF)
+
+if(ENABLE_PERF_TESTS OR ENABLE_STRESS_TESTS)
+    set(THREADS_PREFER_PTHREAD_FLAG ON)
+    find_package(Threads REQUIRED)
+
+    if(ENABLE_PERF_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})
+        target_link_libraries(sdbus-c++-perf-tests-server sdbus-c++ Threads::Threads)
+    endif()
+
+    if(ENABLE_STRESS_TESTS)
+        add_executable(sdbus-c++-stress-tests ${STRESSTESTS_SRCS})
+        target_link_libraries(sdbus-c++-stress-tests sdbus-c++ Threads::Threads)
+    endif()
+endif()
+
+#----------------------------------
+# INSTALLATION
+#----------------------------------
+
+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)
+
+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)
+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)
+endif()
+
+#----------------------------------
+# RUNNING THE TESTS UPON BUILD
+#----------------------------------
+
+if(NOT CMAKE_CROSSCOMPILING)
+    add_test(NAME sdbus-c++-unit-tests COMMAND sdbus-c++-unit-tests)
+    add_test(NAME sdbus-c++-integration-tests COMMAND sdbus-c++-integration-tests)
+endif() 

tests/googletest-download/CMakeLists.txt.in

@@ -1,6 +1,6 @@
 # Taken from https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project
 
-cmake_minimum_required(VERSION 2.8.2)
+cmake_minimum_required(VERSION 3.6)
 
 project(googletest-download NONE)
 
@@ -9,8 +9,10 @@ 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   ""

tests/integrationtests/AdaptorAndProxy_test.cpp

@@ -0,0 +1,771 @@
+/**
+ * (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->enterEventLoopAsync();
+    }
+
+    static void TearDownTestCase()
+    {
+        s_connection->leaveEventLoop();
+        s_connection->releaseName(INTERFACE_NAME);
+    }
+
+    template <typename _Fnc>
+    static bool waitUntil(_Fnc&& fnc, 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 (!fnc());
+
+        return true;
+    }
+
+    static bool waitUntil(std::atomic<bool>& flag, std::chrono::milliseconds timeout = 5s)
+    {
+        return waitUntil([&flag]() -> bool { return flag; }, timeout);
+    }
+
+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();
+
+}
+
+using SdbusTestObject = AdaptorAndProxyFixture;
+
+/*-------------------------------------*/
+/* --          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
+
+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->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, 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, 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, EmitsSimpleSignalToMultipleProxiesSuccesfully)
+{
+    auto proxy1 = std::make_unique<TestingProxy>(*s_connection, INTERFACE_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestingProxy>(*s_connection, INTERFACE_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, 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));
+#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_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
+#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_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,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Connection_test.cpp
  *
@@ -46,7 +47,7 @@ using ::testing::Eq;
 
 TEST(Connection, CanBeDefaultConstructed)
 {
-    ASSERT_NO_THROW(sdbus::createConnection());
+    ASSERT_NO_THROW(auto con = sdbus::createConnection());
 }
 
 TEST(Connection, CanRequestRegisteredDbusName)
@@ -77,13 +78,13 @@ TEST(Connection, CannotReleaseNonrequestedName)
     ASSERT_THROW(connection->releaseName("some.random.nonrequested.name"), sdbus::Error);
 }
 
-TEST(Connection, CanEnterAndLeaveProcessingLoop)
+TEST(Connection, CanEnterAndLeaveEventLoop)
 {
     auto connection = sdbus::createConnection();
     connection->requestName(INTERFACE_NAME);
 
-    std::thread t([&](){ connection->enterProcessingLoop(); });
-    connection->leaveProcessingLoop();
+    std::thread t([&](){ connection->enterEventLoop(); });
+    connection->leaveEventLoop();
 
     t.join();
 

tests/integrationtests/TestingAdaptor.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file TestingAdaptor.h
  *
@@ -31,35 +32,50 @@
 #include <chrono>
 #include <atomic>
 
-class TestingAdaptor : public sdbus::Interfaces<testing_adaptor>
+class TestingAdaptor : public sdbus::AdaptorInterfaces< testing_adaptor
+                                                      , sdbus::Properties_adaptor
+                                                      , sdbus::ObjectManager_adaptor >
 {
 public:
     TestingAdaptor(sdbus::IConnection& connection) :
-        sdbus::Interfaces<::testing_adaptor>(connection, OBJECT_PATH) { }
+        AdaptorInterfaces(connection, OBJECT_PATH)
+    {
+        registerAdaptor();
+    }
 
-    virtual ~TestingAdaptor() { }
-
-    bool wasMultiplyCalled() const { return m_multiplyCalled; }
-    double getMultiplyResult() const { return m_multiplyResult; }
-    bool wasThrowErrorCalled() const { return m_throwErrorCalled; }
+    ~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
+    void noArgNoReturn() const override
     {
-        m_multiplyResult = a * b;
-        m_multiplyCalled = true;
     }
 
-    std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x) const
+    int32_t getInt() const override
+    {
+        return INT32_VALUE;
+    }
+
+    std::tuple<uint32_t, std::string> getTuple() const override
+    {
+        return std::make_tuple(UINT32_VALUE, STRING_VALUE);
+    }
+
+    double multiply(const int64_t& a, const double& b) const override
+    {
+        return a * b;
+    }
+
+    void multiplyWithNoReply(const int64_t& a, const double& b) const override
+    {
+        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 override
     {
         std::vector<int16_t> res{x.get<1>()};
         auto y = std::get<std::vector<int16_t>>(x);
@@ -67,13 +83,13 @@ protected:
         return res;
     }
 
-    sdbus::Variant processVariant(sdbus::Variant& v)
+    sdbus::Variant processVariant(sdbus::Variant& v) override
     {
         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> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) const override
     {
         std::map<int32_t, sdbus::Variant> res;
         for (auto item : x)
@@ -83,12 +99,12 @@ protected:
         return res;
     }
 
-    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() const
+    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() const override
     {
         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 sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b) override
     {
         int32_t res{0};
         res += std::get<0>(a) + std::get<1>(a);
@@ -96,7 +112,7 @@ protected:
         return res;
     }
 
-    uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b)
+    uint32_t sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b) override
     {
         uint32_t res{0};
         for (auto x : a)
@@ -110,13 +126,13 @@ protected:
         return res;
     }
 
-    uint32_t doOperation(uint32_t param)
+    uint32_t doOperation(uint32_t param) override
     {
         std::this_thread::sleep_for(std::chrono::milliseconds(param));
         return param;
     }
 
-    void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result)
+    void doOperationAsync(uint32_t param, sdbus::Result<uint32_t> result) override
     {
         if (param == 0)
         {
@@ -134,10 +150,20 @@ protected:
         }
     }
 
-    sdbus::Signature getSignature() const { return SIGNATURE_VALUE; }
-    sdbus::ObjectPath getObjectPath() const { return OBJECT_PATH_VALUE; }
+    sdbus::Signature getSignature() const override
+    {
+        return SIGNATURE_VALUE;
+    }
+    sdbus::ObjectPath getObjPath() const override
+    {
+        return OBJECT_PATH_VALUE;
+    }
+    sdbus::UnixFd getUnixFd() const override
+    {
+        return sdbus::UnixFd{UNIX_FD_VALUE};
+    }
 
-    ComplexType getComplex() const
+    ComplexType getComplex() const override
     {
         return { // map
             {
@@ -165,26 +191,54 @@ protected:
         };
     }
 
-    void throwError() const
+    void throwError() const override
     {
-        m_throwErrorCalled = true;
+        m_wasThrowErrorCalled = true;
         throw sdbus::createError(1, "A test error occurred");
     }
 
-    std::string state() { return STRING_VALUE; }
-    uint32_t action() { return m_action; }
-    void action(const uint32_t& value) { m_action = value; }
-    bool blocking() { return m_blocking; }
-    void blocking(const bool& value) { m_blocking = value; }
+
+    void emitTwoSimpleSignals() override
+    {
+        emitSimpleSignal();
+        emitSignalWithMap({});
+    }
+
+    std::string state() override
+    {
+        return m_state;
+    }
+
+    uint32_t action() override
+    {
+        return m_action;
+    }
+
+    void action(const uint32_t& value) override
+    {
+        m_action = value;
+    }
+
+    bool blocking() override
+    {
+        return m_blocking;
+    }
+
+    void blocking(const bool& value) override
+    {
+        m_blocking = value;
+    }
 
 private:
-    uint32_t m_action;
-    bool m_blocking;
+    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_multiplyCalled{};
+    mutable std::atomic<bool> m_wasMultiplyCalled{false};
     mutable double m_multiplyResult{};
-    mutable std::atomic<bool> m_throwErrorCalled{};
+    mutable std::atomic<bool> m_wasThrowErrorCalled{false};
 };
 
 

tests/integrationtests/TestingProxy.h

@@ -0,0 +1,132 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file TestingProxy.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_TESTINGPROXY_H_
+#define SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_
+
+#include "proxy-glue.h"
+#include <atomic>
+
+class TestingProxy : public sdbus::ProxyInterfaces< ::testing_proxy
+                                                  , sdbus::Peer_proxy
+                                                  , sdbus::Introspectable_proxy
+                                                  , sdbus::Properties_proxy
+                                                  , sdbus::ObjectManager_proxy >
+{
+public:
+    TestingProxy(std::string destination, std::string objectPath)
+        : ProxyInterfaces(std::move(destination), std::move(objectPath))
+    {
+        registerProxy();
+    }
+
+    TestingProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
+        : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
+    {
+        registerProxy();
+    }
+
+    ~TestingProxy()
+    {
+        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
+    {
+        if (m_onInterfacesAddedHandler)
+            m_onInterfacesAddedHandler(objectPath, interfacesAndProperties);
+    }
+    void onInterfacesRemoved( const sdbus::ObjectPath& objectPath
+                            , const std::vector<std::string>& interfaces) override
+    {
+        if (m_onInterfacesRemovedHandler)
+            m_onInterfacesRemovedHandler(objectPath, interfaces);
+    }
+
+//private:
+public: // for tests
+    int m_SimpleSignals = 0;
+    std::atomic<bool> m_gotSimpleSignal{false};
+    std::atomic<bool> m_gotSignalWithMap{false};
+    std::map<int32_t, std::string> m_mapFromSignal;
+    std::atomic<bool> m_gotSignalWithVariant{false};
+    double m_variantFromSignal;
+    std::atomic<bool> m_gotSignalWithSignature{false};
+    std::map<std::string, std::string> m_signatureFromSignal;
+
+    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;
+};
+
+#endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTINGPROXY_H_ */

tests/integrationtests/adaptor-glue.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file adaptor-glue.h
  *
@@ -52,7 +53,6 @@ using ComplexType = std::map<
 
 class testing_adaptor
 {
-
 protected:
     testing_adaptor(sdbus::IObject& object) :
         object_(object)
@@ -60,17 +60,18 @@ protected:
         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("getInt").onInterface(INTERFACE_NAME).withOutputParamNames("anInt").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("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).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](
+        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).implementedAs([this](){ return this->getStructInStruct(); });
@@ -96,7 +97,8 @@ protected:
         });
 
         object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getSignature(); });
-        object_.registerMethod("getObjectPath").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getObjectPath(); });
+        object_.registerMethod("getObjPath").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getObjPath(); });
+        object_.registerMethod("getUnixFd").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getUnixFd(); });
 
         object_.registerMethod("getComplex").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getComplex(); }).markAsDeprecated();
 
@@ -105,34 +107,39 @@ protected:
 
         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>();
+        // Note: sd-bus of libsystemd up to (including) v244 has a bug where it doesn't generate signal parameter names in introspection XML. Signal param names commented temporarily.
+        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("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE);
-        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
-        object_.registerProperty("blocking").onInterface(INTERFACE_NAME)./*withGetter([this](){ return this->blocking(); }).*/withSetter([this](const bool& value){ this->blocking(value); });
-
+        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 simpleSignal()
+    void emitSimpleSignal()
     {
         object_.emitSignal("simpleSignal").onInterface(INTERFACE_NAME);
     }
 
-    void signalWithMap(const std::map<int32_t, std::string>& map)
+    void emitSignalWithMap(const std::map<int32_t, std::string>& map)
     {
         object_.emitSignal("signalWithMap").onInterface(INTERFACE_NAME).withArguments(map);
     }
 
-    void signalWithVariant(const sdbus::Variant& v)
+    void emitSignalWithVariant(const sdbus::Variant& v)
     {
         object_.emitSignal("signalWithVariant").onInterface(INTERFACE_NAME).withArguments(v);
     }
 
-    void signalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
+    void emitSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s)
     {
         object_.emitSignal("signalWithoutRegistration").onInterface(INTERFACE_NAME).withArguments(s);
     }
@@ -161,9 +168,11 @@ protected:
     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::ObjectPath getObjPath() 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;
@@ -210,7 +219,20 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
    <arg type="as" name="invalidated_properties"/>
   </signal>
  </interface>
- <interface name="com.kistler.testsdbuscpp">
+ <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"/>
@@ -223,23 +245,41 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
   <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 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">
+  <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"/>
+   <arg type="a{iv}" direction="out"/>)delimiter"
+#endif
+R"delimiter(
   </method>
-  <method name="getObjectPath">
+  <method name="getObjPath">
    <arg type="o" direction="out"/>
   </method>
   <method name="getSignature">
@@ -252,10 +292,22 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
    <arg type="u" direction="out"/>
    <arg type="s" direction="out"/>
   </method>
-  <method name="multiply">
+  <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"/>
+   <arg type="d" direction="out"/>)delimiter"
+#endif
+R"delimiter(
   </method>
   <method name="multiplyWithNoReply">
    <arg type="x" direction="in"/>
@@ -294,7 +346,7 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
    <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
   </signal>
   <property name="action" type="u" access="readwrite">
-   <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="false"/>
+   <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="invalidates"/>
   </property>
   <property name="blocking" type="b" access="readwrite">
   </property>

tests/integrationtests/defs.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file defs.h
  *
@@ -28,7 +29,7 @@
 
 #include "sdbus-c++/Types.h"
 
-const std::string INTERFACE_NAME{"com.kistler.testsdbuscpp"};
+const std::string INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
 const std::string OBJECT_PATH{"/"};
 
 constexpr const uint8_t UINT8_VALUE{1};
@@ -40,6 +41,11 @@ constexpr const int32_t INT64_VALUE{-1024};
 const std::string STRING_VALUE{"sdbus-c++-testing"};
 const sdbus::Signature SIGNATURE_VALUE{"a{is}"};
 const sdbus::ObjectPath OBJECT_PATH_VALUE{"/"};
+const int UNIX_FD_VALUE = 0;
+
+const std::string DEFAULT_STATE_VALUE{"default-state-value"};
+const uint32_t DEFAULT_ACTION_VALUE{999};
+const bool DEFAULT_BLOCKING_VALUE{true};
 
 constexpr const double DOUBLE_VALUE{3.24L};
 

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

@@ -8,9 +8,9 @@
   <!-- ../system.conf have denied everything, so we just punch some holes -->
 
   <policy context="default">
-    <allow own="com.kistler.testsdbuscpp"/>
-    <allow send_destination="com.kistler.testsdbuscpp"/>
-    <allow send_interface="com.kistler.testsdbuscpp"/>
+    <allow own="org.sdbuscpp.integrationtests"/>
+    <allow send_destination="org.sdbuscpp.integrationtests"/>
+    <allow send_interface="org.sdbuscpp.integrationtests"/>
   </policy>
 
 </busconfig>

tests/integrationtests/proxy-glue.h

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file proxy-glue.h
  *
@@ -34,7 +35,7 @@
 class testing_proxy
 {
 protected:
-    testing_proxy(sdbus::IObjectProxy& object) :
+    testing_proxy(sdbus::IProxy& object) :
         object_(object)
     {
         object_.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
@@ -45,6 +46,8 @@ protected:
                 { 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;
@@ -53,6 +56,11 @@ protected:
     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);
@@ -133,6 +141,14 @@ public:
         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;
@@ -140,23 +156,38 @@ public:
         return result;
     }
 
-    uint32_t doOperationClientSideAsync(uint32_t param)
+    sdbus::PendingAsyncCall 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);
-        });
+        return object_.callMethodAsync("doOperation")
+                      .onInterface(INTERFACE_NAME)
+                      .withArguments(param)
+                      .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
+                                       {
+                                           this->onDoOperationReply(returnValue, error);
+                                       });
     }
 
-    uint32_t doErroneousOperationClientSideAsync()
+    void doErroneousOperationClientSideAsync()
     {
-        object_.callMethodAsync("throwError").onInterface(INTERFACE_NAME).uponReplyInvoke([this](const sdbus::Error* error)
-        {
-            this->onDoOperationReply(0, error);
-        });
+        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()
@@ -166,10 +197,17 @@ public:
         return result;
     }
 
-    sdbus::ObjectPath getObjectPath()
+    sdbus::ObjectPath getObjPath()
     {
         sdbus::ObjectPath result;
-        object_.callMethod("getObjectPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        object_.callMethod("getObjPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    sdbus::UnixFd getUnixFd()
+    {
+        sdbus::UnixFd result;
+        object_.callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
@@ -209,6 +247,11 @@ public:
         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);
@@ -231,7 +274,7 @@ public:
 
 
 private:
-    sdbus::IObjectProxy& object_;
+    sdbus::IProxy& object_;
 
 };
 

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

@@ -1,7 +1,8 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
- * @file libsdbus-c++_integrationtests.cpp
+ * @file sdbus-c++-integration-tests.cpp
  *
  * Created on: Jan 2, 2017
  * Project: sdbus-c++

tests/perftests/client.cpp

@@ -23,7 +23,7 @@
  * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "perftest-proxy.h"
+#include "perftests-proxy.h"
 #include <sdbus-c++/sdbus-c++.h>
 #include <vector>
 #include <string>
@@ -33,15 +33,24 @@
 #include <chrono>
 #include <cassert>
 #include <algorithm>
+#include <iostream>
 
 using namespace std::chrono_literals;
 
-class PerftestClient : public sdbus::ProxyInterfaces<org::sdbuscpp::perftest_proxy>
+uint64_t totalDuration = 0;
+
+class PerftestProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::perftests_proxy>
 {
 public:
-    PerftestClient(std::string destination, std::string objectPath)
-        : sdbus::ProxyInterfaces<org::sdbuscpp::perftest_proxy>(std::move(destination), std::move(objectPath))
+    PerftestProxy(std::string destination, std::string objectPath)
+        : ProxyInterfaces(std::move(destination), std::move(objectPath))
     {
+        registerProxy();
+    }
+
+    ~PerftestProxy()
+    {
+        unregisterProxy();
     }
 
 protected:
@@ -59,7 +68,9 @@ protected:
         else if (counter == m_msgCount)
         {
             auto stopTime = std::chrono::steady_clock::now();
-            std::cout << "Received " << m_msgCount << " signals in: " << std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count() << " ms" << std::endl;
+            auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count();
+            totalDuration += duration;
+            std::cout << "Received " << m_msgCount << " signals in: " << duration << " ms" << std::endl;
             counter = 0;
         }
     }
@@ -89,9 +100,9 @@ std::string createRandomString(size_t length)
 //-----------------------------------------
 int main(int /*argc*/, char */*argv*/[])
 {
-    const char* destinationName = "org.sdbuscpp.perftest";
-    const char* objectPath = "/org/sdbuscpp/perftest";
-    PerftestClient client(destinationName, objectPath);
+    const char* destinationName = "org.sdbuscpp.perftests";
+    const char* objectPath = "/org/sdbuscpp/perftests";
+    PerftestProxy client(destinationName, objectPath);
 
     const unsigned int repetitions{20};
     unsigned int msgCount = 1000;
@@ -107,6 +118,9 @@ int main(int /*argc*/, char */*argv*/[])
         std::this_thread::sleep_for(1000ms);
     }
 
+    std::cout << "AVERAGE: " << (totalDuration/repetitions) << " ms" << std::endl;
+    totalDuration = 0;
+
     msgSize = 1000;
     std::cout << std::endl << "** Measuring signals of size " << msgSize << " bytes (" << repetitions << " repetitions)..." << std::endl << std::endl;
     client.m_msgCount = msgCount; client.m_msgSize = msgSize;
@@ -117,6 +131,9 @@ int main(int /*argc*/, char */*argv*/[])
         std::this_thread::sleep_for(1000ms);
     }
 
+    std::cout << "AVERAGE: " << (totalDuration/repetitions) << " ms" << std::endl;
+    totalDuration = 0;
+
     msgSize = 20;
     std::cout << std::endl << "** Measuring method calls of size " << msgSize << " bytes (" << repetitions << " repetitions)..." << std::endl << std::endl;
     for (unsigned int r = 0; r < repetitions; ++r)
@@ -133,11 +150,16 @@ int main(int /*argc*/, char */*argv*/[])
             assert(result.size() == msgSize);
         }
         auto stopTime = std::chrono::steady_clock::now();
-        std::cout << "Called " << msgCount << " methods in: " << std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count() << " ms" << std::endl;
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count();
+        totalDuration += duration;
+        std::cout << "Called " << msgCount << " methods in: " << duration << " ms" << std::endl;
 
         std::this_thread::sleep_for(1000ms);
     }
 
+    std::cout << "AVERAGE: " << (totalDuration/repetitions) << " ms" << std::endl;
+    totalDuration = 0;
+
     msgSize = 1000;
     std::cout << std::endl << "** Measuring method calls of size " << msgSize << " bytes (" << repetitions << " repetitions)..." << std::endl << std::endl;
     for (unsigned int r = 0; r < repetitions; ++r)
@@ -154,10 +176,15 @@ int main(int /*argc*/, char */*argv*/[])
             assert(result.size() == msgSize);
         }
         auto stopTime = std::chrono::steady_clock::now();
-        std::cout << "Called " << msgCount << " methods in: " << std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count() << " ms" << std::endl;
+        auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(stopTime - startTime).count();
+        totalDuration += duration;
+        std::cout << "Called " << msgCount << " methods in: " << duration << " ms" << std::endl;
 
         std::this_thread::sleep_for(1000ms);
     }
 
+    std::cout << "AVERAGE: " << (totalDuration/repetitions) << " ms" << std::endl;
+    totalDuration = 0;
+
     return 0;
 }

tests/perftests/files/org.sdbuscpp.perftests.conf

@@ -8,9 +8,9 @@
   <!-- ../system.conf have denied everything, so we just punch some holes -->
 
   <policy context="default">
-    <allow own="org.sdbuscpp.perftest"/>
-    <allow send_destination="org.sdbuscpp.perftest"/>
-    <allow send_interface="org.sdbuscpp.perftest"/>
+    <allow own="org.sdbuscpp.perftests"/>
+    <allow send_destination="org.sdbuscpp.perftests"/>
+    <allow send_interface="org.sdbuscpp.perftests"/>
   </policy>
 
 </busconfig>

tests/perftests/org.sdbuscpp.perftests.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
 <node name="/org/sdbuscpp/perftest">
-    <interface name="org.sdbuscpp.perftest">
+    <interface name="org.sdbuscpp.perftests">
         <method name="sendDataSignals">
             <arg type="u" name="numberOfSignals" direction="in" />
             <arg type="u" name="signalMsgSize" direction="in" />

tests/perftests/perftests-adaptor.h

@@ -0,0 +1,48 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__perftests_adaptor_h__adaptor__H__
+#define __sdbuscpp__perftests_adaptor_h__adaptor__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+
+class perftests_adaptor
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.perftests";
+
+protected:
+    perftests_adaptor(sdbus::IObject& object)
+        : object_(object)
+    {
+        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;
+
+public:
+    void emitDataSignal(const std::string& data)
+    {
+        object_.emitSignal("dataSignal").onInterface(INTERFACE_NAME).withArguments(data);
+    }
+
+private:
+    virtual void sendDataSignals(const uint32_t& numberOfSignals, const uint32_t& signalMsgSize) = 0;
+    virtual std::string concatenateTwoStrings(const std::string& string1, const std::string& string2) = 0;
+
+private:
+    sdbus::IObject& object_;
+};
+
+}} // namespaces
+
+#endif

tests/perftests/perftests-proxy.h

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

tests/perftests/server.cpp

@@ -23,42 +23,48 @@
  * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include "perftest-adaptor.h"
+#include "perftests-adaptor.h"
 #include <sdbus-c++/sdbus-c++.h>
 #include <vector>
 #include <string>
 #include <thread>
 #include <chrono>
 #include <algorithm>
+#include <iostream>
 
 using namespace std::chrono_literals;
 
 std::string createRandomString(size_t length);
 
-class PerftestServer : public sdbus::Interfaces<org::sdbuscpp::perftest_adaptor>
+class PerftestAdaptor : public sdbus::AdaptorInterfaces<org::sdbuscpp::perftests_adaptor>
 {
 public:
-    PerftestServer(sdbus::IConnection& connection, std::string objectPath)
-        : sdbus::Interfaces<org::sdbuscpp::perftest_adaptor>(connection, std::move(objectPath))
+    PerftestAdaptor(sdbus::IConnection& connection, std::string objectPath)
+        : AdaptorInterfaces(connection, std::move(objectPath))
     {
+        registerAdaptor();
+    }
+
+    ~PerftestAdaptor()
+    {
+        unregisterAdaptor();
     }
 
 protected:
     virtual void sendDataSignals(const uint32_t& numberOfSignals, const uint32_t& signalMsgSize) override
     {
         auto data = createRandomString(signalMsgSize);
-        char digits[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
-        
+
         auto start_time = std::chrono::steady_clock::now();
         for (uint32_t i = 0; i < numberOfSignals; ++i)
         {
             // Emit signal
-            dataSignal(data);
+            emitDataSignal(data);
         }
         auto stop_time = std::chrono::steady_clock::now();
         std::cout << "Server sent " << numberOfSignals << " signals in: " << std::chrono::duration_cast<std::chrono::milliseconds>(stop_time - start_time).count() << " ms" << std::endl;
     }
-    
+
     virtual std::string concatenateTwoStrings(const std::string& string1, const std::string& string2) override
     {
         return string1 + string2;
@@ -85,11 +91,11 @@ std::string createRandomString(size_t length)
 //-----------------------------------------
 int main(int /*argc*/, char */*argv*/[])
 {
-    const char* serviceName = "org.sdbuscpp.perftest";
+    const char* serviceName = "org.sdbuscpp.perftests";
     auto connection = sdbus::createSystemBusConnection(serviceName);
 
-    const char* objectPath = "/org/sdbuscpp/perftest";
-    PerftestServer server(*connection, objectPath);
+    const char* objectPath = "/org/sdbuscpp/perftests";
+    PerftestAdaptor server(*connection, objectPath);
 
-    connection->enterProcessingLoop();
+    connection->enterEventLoop();
 }

tests/stresstests/celsius-thermometer-adaptor.h

@@ -1,6 +1,6 @@
 
 /*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
  */
 
 #ifndef __sdbuscpp__celsius_thermometer_adaptor_h__adaptor__H__
@@ -12,21 +12,23 @@
 
 namespace org {
 namespace sdbuscpp {
-namespace stresstest {
+namespace stresstests {
 namespace celsius {
 
 class thermometer_adaptor
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.celsius.thermometer";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.celsius.thermometer";
 
 protected:
     thermometer_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("getCurrentTemperature").onInterface(interfaceName).implementedAs([this](){ return this->getCurrentTemperature(); });
+        object_.registerMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).withOutputParamNames("result").implementedAs([this](){ return this->getCurrentTemperature(); });
     }
 
+    ~thermometer_adaptor() = default;
+
 private:
     virtual uint32_t getCurrentTemperature() = 0;
 

tests/stresstests/celsius-thermometer-proxy.h

@@ -1,6 +1,6 @@
 
 /*
- * This file was automatically generated by sdbuscpp-xml2cpp; DO NOT EDIT!
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
  */
 
 #ifndef __sdbuscpp__celsius_thermometer_proxy_h__proxy__H__
@@ -12,30 +12,32 @@
 
 namespace org {
 namespace sdbuscpp {
-namespace stresstest {
+namespace stresstests {
 namespace celsius {
 
 class thermometer_proxy
 {
 public:
-    static constexpr const char* interfaceName = "org.sdbuscpp.stresstest.celsius.thermometer";
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.celsius.thermometer";
 
 protected:
-    thermometer_proxy(sdbus::IObjectProxy& object)
-        : object_(object)
+    thermometer_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
     {
     }
 
+    ~thermometer_proxy() = default;
+
 public:
     uint32_t getCurrentTemperature()
     {
         uint32_t result;
-        object_.callMethod("getCurrentTemperature").onInterface(interfaceName).storeResultsTo(result);
+        proxy_.callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
 private:
-    sdbus::IObjectProxy& object_;
+    sdbus::IProxy& proxy_;
 };
 
 }}}} // namespaces

tests/stresstests/concatenator-adaptor.h

@@ -0,0 +1,47 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__concatenator_adaptor_h__adaptor__H__
+#define __sdbuscpp__concatenator_adaptor_h__adaptor__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+namespace stresstests {
+
+class concatenator_adaptor
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.concatenator";
+
+protected:
+    concatenator_adaptor(sdbus::IObject& object)
+        : object_(object)
+    {
+        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;
+
+public:
+    void emitConcatenatedSignal(const std::string& concatenatedString)
+    {
+        object_.emitSignal("concatenatedSignal").onInterface(INTERFACE_NAME).withArguments(concatenatedString);
+    }
+
+private:
+    virtual void concatenate(sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params) = 0;
+
+private:
+    sdbus::IObject& object_;
+};
+
+}}} // namespaces
+
+#endif

tests/stresstests/concatenator-proxy.h

@@ -0,0 +1,47 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__concatenator_proxy_h__proxy__H__
+#define __sdbuscpp__concatenator_proxy_h__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+namespace stresstests {
+
+class concatenator_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.concatenator";
+
+protected:
+    concatenator_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+        proxy_.uponSignal("concatenatedSignal").onInterface(INTERFACE_NAME).call([this](const std::string& concatenatedString){ this->onConcatenatedSignal(concatenatedString); });
+    }
+
+    ~concatenator_proxy() = default;
+
+    virtual void onConcatenatedSignal(const std::string& concatenatedString) = 0;
+
+    virtual void onConcatenateReply(const std::string& result, const sdbus::Error* error) = 0;
+
+public:
+    sdbus::PendingAsyncCall concatenate(const std::map<std::string, sdbus::Variant>& params)
+    {
+        return proxy_.callMethodAsync("concatenate").onInterface(INTERFACE_NAME).withArguments(params).uponReplyInvoke([this](const sdbus::Error* error, const std::string& result){ this->onConcatenateReply(result, error); });
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}} // namespaces
+
+#endif

tests/stresstests/fahrenheit-thermometer-adaptor.h

@@ -0,0 +1,72 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__fahrenheit_thermometer_adaptor_h__adaptor__H__
+#define __sdbuscpp__fahrenheit_thermometer_adaptor_h__adaptor__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+namespace stresstests {
+namespace fahrenheit {
+
+class thermometer_adaptor
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.fahrenheit.thermometer";
+
+protected:
+    thermometer_adaptor(sdbus::IObject& object)
+        : object_(object)
+    {
+        object_.registerMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).withOutputParamNames("result").implementedAs([this](){ return this->getCurrentTemperature(); });
+    }
+
+    ~thermometer_adaptor() = default;
+
+private:
+    virtual uint32_t getCurrentTemperature() = 0;
+
+private:
+    sdbus::IObject& object_;
+};
+
+}}}} // namespaces
+
+namespace org {
+namespace sdbuscpp {
+namespace stresstests {
+namespace fahrenheit {
+namespace thermometer {
+
+class factory_adaptor
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.fahrenheit.thermometer.factory";
+
+protected:
+    factory_adaptor(sdbus::IObject& object)
+        : object_(object)
+    {
+        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;
+
+private:
+    virtual void createDelegateObject(sdbus::Result<sdbus::ObjectPath>&& result) = 0;
+    virtual void destroyDelegateObject(sdbus::Result<>&& result, sdbus::ObjectPath delegate) = 0;
+
+private:
+    sdbus::IObject& object_;
+};
+
+}}}}} // namespaces
+
+#endif

tests/stresstests/fahrenheit-thermometer-proxy.h

@@ -0,0 +1,83 @@
+
+/*
+ * This file was automatically generated by sdbus-c++-xml2cpp; DO NOT EDIT!
+ */
+
+#ifndef __sdbuscpp__fahrenheit_thermometer_proxy_h__proxy__H__
+#define __sdbuscpp__fahrenheit_thermometer_proxy_h__proxy__H__
+
+#include <sdbus-c++/sdbus-c++.h>
+#include <string>
+#include <tuple>
+
+namespace org {
+namespace sdbuscpp {
+namespace stresstests {
+namespace fahrenheit {
+
+class thermometer_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.fahrenheit.thermometer";
+
+protected:
+    thermometer_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~thermometer_proxy() = default;
+
+public:
+    uint32_t getCurrentTemperature()
+    {
+        uint32_t result;
+        proxy_.callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}} // namespaces
+
+namespace org {
+namespace sdbuscpp {
+namespace stresstests {
+namespace fahrenheit {
+namespace thermometer {
+
+class factory_proxy
+{
+public:
+    static constexpr const char* INTERFACE_NAME = "org.sdbuscpp.stresstests.fahrenheit.thermometer.factory";
+
+protected:
+    factory_proxy(sdbus::IProxy& proxy)
+        : proxy_(proxy)
+    {
+    }
+
+    ~factory_proxy() = default;
+
+public:
+    sdbus::ObjectPath createDelegateObject()
+    {
+        sdbus::ObjectPath result;
+        proxy_.callMethod("createDelegateObject").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        return result;
+    }
+
+    void destroyDelegateObject(const sdbus::ObjectPath& delegate)
+    {
+        proxy_.callMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).withArguments(delegate).dontExpectReply();
+    }
+
+private:
+    sdbus::IProxy& proxy_;
+};
+
+}}}}} // namespaces
+
+#endif

tests/stresstests/files/org.sdbuscpp.stresstests.conf

@@ -8,15 +8,15 @@
   <!-- ../system.conf have denied everything, so we just punch some holes -->
 
   <policy context="default">
-    <allow own="org.sdbuscpp.stresstest.service1"/>
-    <allow send_destination="org.sdbuscpp.stresstest.service1"/>
-    <allow send_interface="org.sdbuscpp.stresstest.service1"/>
+    <allow own="org.sdbuscpp.stresstests.service1"/>
+    <allow send_destination="org.sdbuscpp.stresstests.service1"/>
+    <allow send_interface="org.sdbuscpp.stresstests.service1"/>
   </policy>
   
   <policy context="default">
-    <allow own="org.sdbuscpp.stresstest.service2"/>
-    <allow send_destination="org.sdbuscpp.stresstest.service2"/>
-    <allow send_interface="org.sdbuscpp.stresstest.service2"/>
+    <allow own="org.sdbuscpp.stresstests.service2"/>
+    <allow send_destination="org.sdbuscpp.stresstests.service2"/>
+    <allow send_interface="org.sdbuscpp.stresstests.service2"/>
   </policy>
 
 </busconfig>

tests/stresstests/org.sdbuscpp.stresstest.celsius.thermometer.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<node name="/org/sdbuscpp/stresstest/celsius/thermometer">
-    <interface name="org.sdbuscpp.stresstest.celsius.thermometer">
+<node name="/org/sdbuscpp/stresstests/celsius/thermometer">
+    <interface name="org.sdbuscpp.stresstests.celsius.thermometer">
         <method name="getCurrentTemperature">
             <arg type="u" name="result" direction="out" />
         </method>

tests/stresstests/org.sdbuscpp.stresstest.concatenator.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 
-<node name="/org/sdbuscpp/stresstest/concatenator">
-    <interface name="org.sdbuscpp.stresstest.concatenator">
+<node name="/org/sdbuscpp/stresstests/concatenator">
+    <interface name="org.sdbuscpp.stresstests.concatenator">
         <method name="concatenate">
             <arg type="a{sv}" name="params" direction="in" />
             <arg type="s" name="result" direction="out" />

tests/stresstests/org.sdbuscpp.stresstest.fahrenheit.thermometer.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<node name="/org/sdbuscpp/stresstests/fahrenheit/thermometer">
+    <interface name="org.sdbuscpp.stresstests.fahrenheit.thermometer">
+        <method name="getCurrentTemperature">
+            <arg type="u" name="result" direction="out" />
+        </method>
+    </interface>
+    <interface name="org.sdbuscpp.stresstests.fahrenheit.thermometer.factory">
+        <method name="createDelegateObject">
+            <arg type="o" name="delegate" direction="out" />
+            <annotation name="org.freedesktop.DBus.Method.Async" value="server" />
+        </method>
+        <method name="destroyDelegateObject">
+            <arg type="o" name="delegate" direction="in" />
+            <annotation name="org.freedesktop.DBus.Method.Async" value="server" />
+            <annotation name="org.freedesktop.DBus.Method.NoReply" value="true" />
+        </method>
+    </interface>
+</node>

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

@@ -0,0 +1,514 @@
+/**
+ * (C) 2019 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ *
+ * @file sdbus-c++-stress-tests.cpp
+ *
+ * Created on: Jan 25, 2019
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "celsius-thermometer-adaptor.h"
+#include "celsius-thermometer-proxy.h"
+#include "fahrenheit-thermometer-adaptor.h"
+#include "fahrenheit-thermometer-proxy.h"
+#include "concatenator-adaptor.h"
+#include "concatenator-proxy.h"
+#include <sdbus-c++/sdbus-c++.h>
+#include <vector>
+#include <string>
+#include <iostream>
+#include <unistd.h>
+#include <thread>
+#include <chrono>
+#include <cassert>
+#include <cstdlib>
+#include <atomic>
+#include <sstream>
+#include <mutex>
+#include <condition_variable>
+#include <queue>
+
+using namespace std::chrono_literals;
+using namespace std::string_literals;
+
+#define SERVICE_1_BUS_NAME "org.sdbuscpp.stresstests.service1"s
+#define SERVICE_2_BUS_NAME "org.sdbuscpp.stresstests.service2"s
+#define CELSIUS_THERMOMETER_OBJECT_PATH "/org/sdbuscpp/stresstests/celsius/thermometer"s
+#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>
+{
+public:
+    CelsiusThermometerAdaptor(sdbus::IConnection& connection, std::string objectPath)
+        : AdaptorInterfaces(connection, std::move(objectPath))
+    {
+        registerAdaptor();
+    }
+
+    ~CelsiusThermometerAdaptor()
+    {
+        unregisterAdaptor();
+    }
+
+protected:
+    virtual uint32_t getCurrentTemperature() override
+    {
+        return m_currentTemperature++;
+    }
+
+private:
+    uint32_t m_currentTemperature{};
+};
+
+class CelsiusThermometerProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstests::celsius::thermometer_proxy>
+{
+public:
+    CelsiusThermometerProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
+        : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
+    {
+        registerProxy();
+    }
+
+    ~CelsiusThermometerProxy()
+    {
+        unregisterProxy();
+    }
+};
+
+class FahrenheitThermometerAdaptor : 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)
+        : AdaptorInterfaces(connection, std::move(objectPath))
+        , celsiusProxy_(connection, SERVICE_2_BUS_NAME, CELSIUS_THERMOMETER_OBJECT_PATH)
+    {
+        if (!isDelegate)
+        {
+            unsigned int workers = std::thread::hardware_concurrency();
+            if (workers < 4)
+                workers = 4;
+
+            for (unsigned int i = 0; i < workers; ++i)
+                workers_.emplace_back([this]()
+                {
+                    //std::cout << "Created FTA worker thread 0x" << std::hex << std::this_thread::get_id() << std::dec << std::endl;
+
+                    while(!exit_)
+                    {
+                        // Pop a work item from the queue
+                        std::unique_lock<std::mutex> lock(mutex_);
+                        cond_.wait(lock, [this]{return !requests_.empty() || exit_;});
+                        if (exit_)
+                            break;
+                        auto request = std::move(requests_.front());
+                        requests_.pop();
+                        lock.unlock();
+
+                        // Either create or destroy a delegate object
+                        if (request.delegateObjectPath.empty())
+                        {
+                            // Create new delegate object
+                            auto& connection = getObject().getConnection();
+                            sdbus::ObjectPath newObjectPath = FAHRENHEIT_THERMOMETER_OBJECT_PATH + "/" + std::to_string(request.objectNr);
+
+                            // Here we are testing dynamic creation of a D-Bus object in an async way
+                            auto adaptor = std::make_unique<FahrenheitThermometerAdaptor>(connection, newObjectPath, true);
+
+                            std::unique_lock<std::mutex> lock{childrenMutex_};
+                            children_.emplace(newObjectPath, std::move(adaptor));
+                            lock.unlock();
+
+                            request.result.returnResults(newObjectPath);
+                        }
+                        else
+                        {
+                            // Destroy existing delegate object
+                            // Here we are testing dynamic removal of a D-Bus object in an async way
+                            std::lock_guard<std::mutex> lock{childrenMutex_};
+                            children_.erase(request.delegateObjectPath);
+                        }
+                    }
+                });
+        }
+
+        registerAdaptor();
+    }
+
+    ~FahrenheitThermometerAdaptor()
+    {
+        exit_ = true;
+        cond_.notify_all();
+        for (auto& worker : workers_)
+            worker.join();
+
+        unregisterAdaptor();
+    }
+
+protected:
+    virtual uint32_t getCurrentTemperature() override
+    {
+        // In this D-Bus call, make yet another D-Bus call to another service over the same connection
+        return static_cast<uint32_t>(celsiusProxy_.getCurrentTemperature() * 1.8 + 32.);
+    }
+
+    virtual void createDelegateObject(sdbus::Result<sdbus::ObjectPath>&& result) override
+    {
+        static size_t objectCounter{};
+        objectCounter++;
+
+        std::unique_lock<std::mutex> lock(mutex_);
+        requests_.push(WorkItem{objectCounter, std::string{}, std::move(result)});
+        lock.unlock();
+        cond_.notify_one();
+    }
+
+    virtual void destroyDelegateObject(sdbus::Result<>&& /*result*/, sdbus::ObjectPath delegate) override
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        requests_.push(WorkItem{0, std::move(delegate), {}});
+        lock.unlock();
+        cond_.notify_one();
+    }
+
+private:
+    CelsiusThermometerProxy celsiusProxy_;
+    std::map<std::string, std::unique_ptr<FahrenheitThermometerAdaptor>> children_;
+    std::mutex childrenMutex_;
+
+    struct WorkItem
+    {
+        size_t objectNr;
+        sdbus::ObjectPath delegateObjectPath;
+        sdbus::Result<sdbus::ObjectPath> result;
+    };
+    std::mutex mutex_;
+    std::condition_variable cond_;
+    std::queue<WorkItem> requests_;
+    std::vector<std::thread> workers_;
+    std::atomic<bool> exit_{};
+};
+
+class FahrenheitThermometerProxy : public sdbus::ProxyInterfaces< org::sdbuscpp::stresstests::fahrenheit::thermometer_proxy
+                                                                , org::sdbuscpp::stresstests::fahrenheit::thermometer::factory_proxy >
+{
+public:
+    FahrenheitThermometerProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
+        : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
+    {
+        registerProxy();
+    }
+
+    ~FahrenheitThermometerProxy()
+    {
+        unregisterProxy();
+    }
+};
+
+class ConcatenatorAdaptor : public sdbus::AdaptorInterfaces<org::sdbuscpp::stresstests::concatenator_adaptor>
+{
+public:
+    ConcatenatorAdaptor(sdbus::IConnection& connection, std::string objectPath)
+        : AdaptorInterfaces(connection, std::move(objectPath))
+    {
+        unsigned int workers = std::thread::hardware_concurrency();
+        if (workers < 4)
+            workers = 4;
+
+        for (unsigned int i = 0; i < workers; ++i)
+            workers_.emplace_back([this]()
+            {
+                //std::cout << "Created CA worker thread 0x" << std::hex << std::this_thread::get_id() << std::dec << std::endl;
+
+                while(!exit_)
+                {
+                    // Pop a work item from the queue
+                    std::unique_lock<std::mutex> lock(mutex_);
+                    cond_.wait(lock, [this]{return !requests_.empty() || exit_;});
+                    if (exit_)
+                        break;
+                    auto request = std::move(requests_.front());
+                    requests_.pop();
+                    lock.unlock();
+
+                    // Do concatenation work, return results and fire signal
+                    auto aString = request.input.at("key1").get<std::string>();
+                    auto aNumber = request.input.at("key2").get<uint32_t>();
+                    auto resultString = aString + " " + std::to_string(aNumber);
+
+                    request.result.returnResults(resultString);
+
+                    emitConcatenatedSignal(resultString);
+                }
+            });
+
+        registerAdaptor();
+    }
+
+    ~ConcatenatorAdaptor()
+    {
+        exit_ = true;
+        cond_.notify_all();
+        for (auto& worker : workers_)
+            worker.join();
+
+        unregisterAdaptor();
+    }
+
+protected:
+    virtual void concatenate(sdbus::Result<std::string>&& result, std::map<std::string, sdbus::Variant> params) override
+    {
+        std::unique_lock<std::mutex> lock(mutex_);
+        requests_.push(WorkItem{std::move(params), std::move(result)});
+        lock.unlock();
+        cond_.notify_one();
+    }
+
+private:
+    struct WorkItem
+    {
+        std::map<std::string, sdbus::Variant> input;
+        sdbus::Result<std::string> result;
+    };
+    std::mutex mutex_;
+    std::condition_variable cond_;
+    std::queue<WorkItem> requests_;
+    std::vector<std::thread> workers_;
+    std::atomic<bool> exit_{};
+};
+
+class ConcatenatorProxy : public sdbus::ProxyInterfaces<org::sdbuscpp::stresstests::concatenator_proxy>
+{
+public:
+    ConcatenatorProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
+        : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
+    {
+        registerProxy();
+    }
+
+    ~ConcatenatorProxy()
+    {
+        unregisterProxy();
+    }
+
+private:
+    virtual void onConcatenateReply(const std::string& result, const sdbus::Error* error) override
+    {
+        assert(error == nullptr);
+
+        std::stringstream str(result);
+        std::string aString;
+        str >> aString;
+        assert(aString == "sdbus-c++-stress-tests");
+
+        uint32_t aNumber;
+        str >> aNumber;
+        assert(aNumber > 0);
+
+        ++repliesReceived_;
+    }
+
+    virtual void onConcatenatedSignal(const std::string& concatenatedString) override
+    {
+        std::stringstream str(concatenatedString);
+        std::string aString;
+        str >> aString;
+        assert(aString == "sdbus-c++-stress-tests");
+
+        uint32_t aNumber;
+        str >> aNumber;
+        assert(aNumber > 0);
+
+        ++signalsReceived_;
+    }
+
+public:
+    std::atomic<uint32_t> repliesReceived_{};
+    std::atomic<uint32_t> signalsReceived_{};
+};
+
+//-----------------------------------------
+int main(int argc, char *argv[])
+{
+    long loops;
+    long loopDuration;
+
+    if (argc == 1)
+    {
+        loops = 1;
+        loopDuration = 30000;
+    }
+    else if (argc == 3)
+    {
+        loops = std::atol(argv[1]);
+        loopDuration = std::atol(argv[2]);
+    }
+    else
+        throw std::runtime_error("Wrong program options");
+
+    std::cout << "Going on with " << loops << " loops and " << loopDuration << "ms loop duration" << std::endl;
+
+    std::atomic<uint32_t> concatenationCallsMade{0};
+    std::atomic<uint32_t> concatenationRepliesReceived{0};
+    std::atomic<uint32_t> concatenationSignalsReceived{0};
+    std::atomic<uint32_t> thermometerCallsMade{0};
+
+    std::atomic<bool> exitLogger{};
+    std::thread loggerThread([&]()
+    {
+        while (!exitLogger)
+        {
+            std::this_thread::sleep_for(1s);
+
+            std::cout << "Made " << concatenationCallsMade << " concatenation calls, received " << concatenationRepliesReceived << " replies and " << concatenationSignalsReceived << " signals so far." << std::endl;
+            std::cout << "Made " << thermometerCallsMade << " thermometer calls so far." << std::endl << std::endl;
+        }
+    });
+
+    for (long loop = 0; loop < loops; ++loop)
+    {
+        std::cout << "Entering loop " << loop+1 << std::endl;
+
+        auto service2Connection = sdbus::createSystemBusConnection(SERVICE_2_BUS_NAME);
+        std::atomic<bool> service2ThreadReady{};
+        std::thread service2Thread([&con = *service2Connection, &service2ThreadReady]()
+        {
+            CelsiusThermometerAdaptor thermometer(con, CELSIUS_THERMOMETER_OBJECT_PATH);
+            service2ThreadReady = true;
+            con.enterEventLoop();
+        });
+
+        auto service1Connection = sdbus::createSystemBusConnection(SERVICE_1_BUS_NAME);
+        std::atomic<bool> service1ThreadReady{};
+        std::thread service1Thread([&con = *service1Connection, &service1ThreadReady]()
+        {
+            ConcatenatorAdaptor concatenator(con, CONCATENATOR_OBJECT_PATH);
+            FahrenheitThermometerAdaptor thermometer(con, FAHRENHEIT_THERMOMETER_OBJECT_PATH, false);
+            service1ThreadReady = true;
+            con.enterEventLoop();
+        });
+
+        // Wait for both services to export their D-Bus objects
+        while (!service2ThreadReady || !service1ThreadReady)
+            std::this_thread::sleep_for(1ms);
+
+        auto clientConnection = sdbus::createSystemBusConnection();
+        std::mutex clientThreadExitMutex;
+        std::condition_variable clientThreadExitCond;
+        bool clientThreadExit{};
+        std::thread clientThread([&, &con = *clientConnection]()
+        {
+            std::atomic<bool> stopClients{false};
+
+            std::thread concatenatorThread([&]()
+            {
+                ConcatenatorProxy concatenator(con, SERVICE_1_BUS_NAME, CONCATENATOR_OBJECT_PATH);
+
+                uint32_t localCounter{};
+
+                // Issue async concatenate calls densely one after another
+                while (!stopClients)
+                {
+                    std::map<std::string, sdbus::Variant> param;
+                    param["key1"] = "sdbus-c++-stress-tests";
+                    param["key2"] = ++localCounter;
+
+                    concatenator.concatenate(param);
+
+                    if ((localCounter % 10) == 0)
+                    {
+                        // Make sure the system is catching up with our async requests,
+                        // otherwise sleep a bit to slow down flooding the server.
+                        assert(localCounter >= concatenator.repliesReceived_);
+                        while ((localCounter - concatenator.repliesReceived_) > 40 && !stopClients)
+                            std::this_thread::sleep_for(1ms);
+
+                        // Update statistics
+                        concatenationCallsMade = localCounter;
+                        concatenationRepliesReceived = (uint32_t)concatenator.repliesReceived_;
+                        concatenationSignalsReceived = (uint32_t)concatenator.signalsReceived_;
+                    }
+                }
+            });
+
+            std::thread thermometerThread([&]()
+            {
+                // Here we continuously remotely call getCurrentTemperature(). We have one proxy object,
+                // first we use it's factory interface to create another proxy object, call getCurrentTemperature()
+                // on that one, and then destroy that proxy object. All that continously in a loop.
+                // This tests dynamic creation and destruction of remote D-Bus objects and local object proxies.
+
+                FahrenheitThermometerProxy thermometer(con, SERVICE_1_BUS_NAME, FAHRENHEIT_THERMOMETER_OBJECT_PATH);
+                uint32_t localCounter{};
+                uint32_t previousTemperature{};
+
+                while (!stopClients)
+                {
+                    localCounter++;
+
+                    auto newObjectPath = thermometer.createDelegateObject();
+                    FahrenheitThermometerProxy proxy{con, SERVICE_1_BUS_NAME, newObjectPath};
+
+                    auto temperature = proxy.getCurrentTemperature();
+                    assert(temperature >= previousTemperature); // The temperature shall rise continually
+                    previousTemperature = temperature;
+                    //std::this_thread::sleep_for(1ms);
+
+                    if ((localCounter % 10) == 0)
+                        thermometerCallsMade = localCounter;
+
+                    thermometer.destroyDelegateObject(newObjectPath);
+                }
+            });
+
+            // 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.enterEventLoop();
+            con.enterEventLoopAsync();
+
+            std::unique_lock<std::mutex> lock(clientThreadExitMutex);
+            clientThreadExitCond.wait(lock, [&]{return clientThreadExit;});
+
+            stopClients = true;
+            thermometerThread.join();
+            concatenatorThread.join();
+        });
+
+        std::this_thread::sleep_for(std::chrono::milliseconds(loopDuration));
+
+        //clientConnection->leaveEventLoop();
+        std::unique_lock<std::mutex> lock(clientThreadExitMutex);
+        clientThreadExit = true;
+        lock.unlock();
+        clientThreadExitCond.notify_one();
+        clientThread.join();
+
+        service1Connection->leaveEventLoop();
+        service1Thread.join();
+
+        service2Connection->leaveEventLoop();
+        service2Thread.join();
+    }
+
+    exitLogger = true;
+    loggerThread.join();
+    
+    return 0;
+}

tests/unittests/Connection_test.cpp

@@ -0,0 +1,172 @@
+/**
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
+ *
+ * @file Connection_test.cpp
+ * @author Ardazishvili Roman (ardazishvili.roman@yandex.ru)
+ *
+ * Created on: Feb 4, 2019
+ * Project: sdbus-c++
+ * Description: High-level D-Bus IPC C++ library based on sd-bus
+ *
+ * This file is part of sdbus-c++.
+ *
+ * sdbus-c++ is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 2.1 of the License, or
+ * (at your option) any later version.
+ *
+ * sdbus-c++ is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Connection.h"
+#include "unittests/mocks/SdBusMock.h"
+
+#include <gtest/gtest.h>
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::SetArgPointee;
+using ::testing::Return;
+using ::testing::NiceMock;
+using 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;
+
+class ConnectionCreationTest : public ::testing::Test
+{
+protected:
+    ConnectionCreationTest() = default;
+
+    std::unique_ptr<NiceMock<SdBusMock>> sdBusIntfMock_ = std::make_unique<NiceMock<SdBusMock>>();
+    sd_bus* fakeBusPtr_ = reinterpret_cast<sd_bus*>(1);
+};
+
+using ASystemBusConnection = ConnectionCreationTest;
+using ASessionBusConnection = ConnectionCreationTest;
+
+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);
+}
+
+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);
+}
+
+TEST_F(ASystemBusConnection, 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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+namespace
+{
+template <typename _BusTypeTag>
+class AConnectionNameRequest : public ::testing::Test
+{
+protected:
+    void setUpBusOpenExpectation();
+    std::unique_ptr<Connection> makeConnection();
+
+    void SetUp() override
+    {
+        setUpBusOpenExpectation();
+        ON_CALL(*sdBusIntfMock_, sd_bus_flush(_)).WillByDefault(Return(1));
+        ON_CALL(*sdBusIntfMock_, sd_bus_flush_close_unref(_)).WillByDefault(Return(fakeBusPtr_));
+        con_ = makeConnection();
+    }
+
+    NiceMock<SdBusMock>* sdBusIntfMock_ = new NiceMock<SdBusMock>(); // con_ below will assume ownership
+    sd_bus* fakeBusPtr_ = reinterpret_cast<sd_bus*>(1);
+    std::unique_ptr<Connection> con_;
+};
+
+template<> void AConnectionNameRequest<Connection::system_bus_t>::setUpBusOpenExpectation()
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_system(_)).WillOnce(DoAll(SetArgPointee<0>(fakeBusPtr_), Return(1)));
+}
+template<> void AConnectionNameRequest<Connection::session_bus_t>::setUpBusOpenExpectation()
+{
+    EXPECT_CALL(*sdBusIntfMock_, sd_bus_open_user(_)).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 <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::remote_system_bus_t>::makeConnection()
+{
+    return std::make_unique<Connection>(std::unique_ptr<NiceMock<SdBusMock>>(sdBusIntfMock_), remote_system_bus, "some host");
+}
+
+typedef ::testing::Types< Connection::system_bus_t
+                        , Connection::session_bus_t
+                        , Connection::remote_system_bus_t
+                        > BusTypeTags;
+
+TYPED_TEST_SUITE(AConnectionNameRequest, BusTypeTags);
+}
+
+TYPED_TEST(AConnectionNameRequest, DoesNotThrowOnSuccess)
+{
+    EXPECT_CALL(*this->sdBusIntfMock_, sd_bus_request_name(_, _, _)).WillOnce(Return(1));
+    this->con_->requestName("org.sdbuscpp.somename");
+}
+
+TYPED_TEST(AConnectionNameRequest, ThrowsOnFail)
+{
+    EXPECT_CALL(*this->sdBusIntfMock_, sd_bus_request_name(_, _, _)).WillOnce(Return(-1));
+
+    ASSERT_THROW(this->con_->requestName("org.sdbuscpp.somename"), sdbus::Error);
+}

tests/unittests/Message_test.cpp

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file Message_test.cpp
  *
@@ -30,12 +31,13 @@
 #include <cstdint>
 
 using ::testing::Eq;
+using ::testing::Gt;
 using ::testing::DoubleEq;
 using namespace std::string_literals;
 
 namespace
 {
-    std::string deserializeString(sdbus::Message& msg)
+    std::string deserializeString(sdbus::PlainMessage& msg)
     {
         std::string str;
         msg >> str;
@@ -49,29 +51,29 @@ namespace
 
 TEST(AMessage, CanBeDefaultConstructed)
 {
-    ASSERT_NO_THROW(sdbus::Message());
+    ASSERT_NO_THROW(sdbus::PlainMessage());
 }
 
 TEST(AMessage, IsInvalidAfterDefaultConstructed)
 {
-    sdbus::Message msg;
+    sdbus::PlainMessage msg;
 
     ASSERT_FALSE(msg.isValid());
 }
 
 TEST(AMessage, IsValidWhenConstructedAsRealMessage)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
     ASSERT_TRUE(msg.isValid());
 }
 
 TEST(AMessage, CreatesShallowCopyWhenCopyConstructed)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
     msg << "I am a string"s;
     msg.seal();
 
-    sdbus::Message msgCopy = msg;
+    sdbus::PlainMessage msgCopy = msg;
 
     std::string str;
     msgCopy >> str;
@@ -82,11 +84,11 @@ TEST(AMessage, CreatesShallowCopyWhenCopyConstructed)
 
 TEST(AMessage, CreatesDeepCopyWhenEplicitlyCopied)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
     msg << "I am a string"s;
     msg.seal();
 
-    sdbus::Message msgCopy{sdbus::createPlainMessage()};
+    auto msgCopy = sdbus::createPlainMessage();
     msg.copyTo(msgCopy, true);
     msgCopy.seal(); // Seal to be able to read from it subsequently
     msg.rewind(true); // Rewind to the beginning after copying
@@ -97,14 +99,14 @@ TEST(AMessage, CreatesDeepCopyWhenEplicitlyCopied)
 
 TEST(AMessage, IsEmptyWhenContainsNoValue)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
 
     ASSERT_TRUE(msg.isEmpty());
 }
 
 TEST(AMessage, IsNotEmptyWhenContainsAValue)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
     msg << "I am a string"s;
 
     ASSERT_FALSE(msg.isEmpty());
@@ -112,7 +114,7 @@ TEST(AMessage, IsNotEmptyWhenContainsAValue)
 
 TEST(AMessage, CanCarryASimpleInteger)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
 
     int dataWritten = 5;
 
@@ -125,9 +127,24 @@ TEST(AMessage, CanCarryASimpleInteger)
     ASSERT_THAT(dataRead, Eq(dataWritten));
 }
 
+TEST(AMessage, CanCarryAUnixFd)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    sdbus::UnixFd dataWritten{0};
+    msg << dataWritten;
+
+    msg.seal();
+
+    sdbus::UnixFd dataRead;
+    msg >> dataRead;
+
+    ASSERT_THAT(dataRead.get(), Gt(dataWritten.get()));
+}
+
 TEST(AMessage, CanCarryAVariant)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
 
     auto dataWritten = sdbus::Variant((double)3.14);
 
@@ -142,7 +159,7 @@ TEST(AMessage, CanCarryAVariant)
 
 TEST(AMessage, CanCarryACollectionOfEmbeddedVariants)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
 
     auto value = std::vector<sdbus::Variant>{"hello"s, (double)3.14};
     auto dataWritten = sdbus::Variant{value};
@@ -159,7 +176,7 @@ TEST(AMessage, CanCarryACollectionOfEmbeddedVariants)
 
 TEST(AMessage, CanCarryAnArray)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
 
     std::vector<int64_t> dataWritten{3545342, 43643532, 324325};
 
@@ -174,7 +191,7 @@ TEST(AMessage, CanCarryAnArray)
 
 TEST(AMessage, CanCarryADictionary)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
 
     std::map<int, std::string> dataWritten{{1, "one"}, {2, "two"}};
 
@@ -189,7 +206,7 @@ TEST(AMessage, CanCarryADictionary)
 
 TEST(AMessage, CanCarryAComplexType)
 {
-    sdbus::Message msg{sdbus::createPlainMessage()};
+    auto msg = sdbus::createPlainMessage();
 
     using ComplexType = std::map<
                             uint64_t,

tests/unittests/TypeTraits_test.cpp

@@ -1,5 +1,6 @@
 /**
- * (C) 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2017 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2019 Stanislav Angelovic <angelovic.s@gmail.com>
  *
  * @file TypeTraits_test.cpp
  *
@@ -72,6 +73,7 @@ namespace
     TYPE(sdbus::ObjectPath)HAS_DBUS_TYPE_SIGNATURE("o")
     TYPE(sdbus::Signature)HAS_DBUS_TYPE_SIGNATURE("g")
     TYPE(sdbus::Variant)HAS_DBUS_TYPE_SIGNATURE("v")
+    TYPE(sdbus::UnixFd)HAS_DBUS_TYPE_SIGNATURE("h")
     TYPE(sdbus::Struct<bool>)HAS_DBUS_TYPE_SIGNATURE("(b)")
     TYPE(sdbus::Struct<uint16_t, double, std::string, sdbus::Variant>)HAS_DBUS_TYPE_SIGNATURE("(qdsv)")
     TYPE(std::vector<int16_t>)HAS_DBUS_TYPE_SIGNATURE("an")
@@ -91,10 +93,11 @@ namespace
                                     >
                                 >,
                                 sdbus::Signature,
+                                sdbus::UnixFd,
                                 const char*
                             >
                         >;
-    TYPE(ComplexType)HAS_DBUS_TYPE_SIGNATURE("a{t(a{ya(obva{is})}gs)}")
+    TYPE(ComplexType)HAS_DBUS_TYPE_SIGNATURE("a{t(a{ya(obva{is})}ghs)}")
 
     typedef ::testing::Types< bool
                             , uint8_t
@@ -110,6 +113,7 @@ namespace
                             , sdbus::ObjectPath
                             , sdbus::Signature
                             , sdbus::Variant
+                            , sdbus::UnixFd
                             , sdbus::Struct<bool>
                             , sdbus::Struct<uint16_t, double, std::string, sdbus::Variant>
                             , std::vector<int16_t>
@@ -117,7 +121,7 @@ namespace
                             , ComplexType
                             > DBusSupportedTypes;
 
-    TYPED_TEST_CASE(Type2DBusTypeSignatureConversion, DBusSupportedTypes);
+    TYPED_TEST_SUITE(Type2DBusTypeSignatureConversion, DBusSupportedTypes);
 }
 
 /*-------------------------------------*/