fix(ci): rename cmake parameters

This PR makes things around connection factories a little more consistent and more intuitive:

    * createConnection() has been removed. One shall call more expressive createSystemConnection() instead to get a connection to the system bus.
    * createDefaultBusConnection() has been renamed to createBusConnection(), so as not to be confused with libsystemd's default_bus, which is a different thing (a reusable thread-local bus).

Proxies still by default call createBusConnection() to get a connection when the connection is not provided explicitly by the caller, but now createBusConnection() does a different thing, so now the proxies connect to either session bus or system bus depending on the context (as opposed to always to system bus like before).

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,23 @@
+---
+name: Bug report
+about: Create a report to help us improve
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**To Reproduce**
+Steps to reproduce the behavior.
+
+**Expected behavior**
+A clear and concise description of what you expected to happen.
+
+**Real (buggy) behavior**
+A clear and concise description of what really happened in contrast to your expectation.
+
+**Additional context**
+Add any other context about the problem here, like version of sdbus-c++ library, version of systemd used, OS used.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,20 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: ''
+labels: ''
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/ci.yml

@@ -4,7 +4,9 @@ on:
   push:
     branches: [ master ]
   pull_request:
-    branches: [ master ]
+    branches:
+      - master
+      - release/v2.0
 
 jobs:
   build:
@@ -12,15 +14,18 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-18.04, ubuntu-20.04]
+        os: [ubuntu-20.04, ubuntu-22.04]
         compiler: [g++, clang]
         build: [shared-libsystemd]
         include:
-          - os: ubuntu-20.04
+          - os: ubuntu-22.04
             compiler: g++
             build: embedded-static-libsystemd
+          - os: ubuntu-22.04
+            compiler: clang
+            build: embedded-static-libsystemd
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v3
     - name: install-libsystemd-toolchain
       if: matrix.build == 'embedded-static-libsystemd'
       run: |
@@ -39,33 +44,47 @@ jobs:
         sudo update-alternatives --install /usr/bin/cc cc /usr/bin/clang 10
         sudo update-alternatives --remove-all c++
         sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 10
-    - name: configure-debug
-      if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-18.04'
+    - name: install-googletest
+      if: matrix.os == 'ubuntu-22.04'
       run: |
+        sudo apt-get install -y libgmock-dev
+    - name: install-googletest
+      if: matrix.os == 'ubuntu-20.04' # On older ubuntus the libgmock-dev package is either unavailable or has faulty pkg-config file, so we build & install manually
+      run: |
+        git clone https://github.com/google/googletest.git
+        cd googletest
         mkdir build
         cd build
-        cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="-O0 -g -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
-    - name: configure-release
+        cmake ..
+        cmake --build . -j4
+        sudo cmake --build . --target install
+    - name: configure-debug
       if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-20.04'
       run: |
         mkdir build
         cd build
-        cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_CXX_FLAGS="-O3 -DNDEBUG -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
+        cmake -DCMAKE_BUILD_TYPE=Debug -DCMAKE_INSTALL_PREFIX:PATH=/usr -DCMAKE_CXX_FLAGS="-O0 -g -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DCMAKE_VERBOSE_MAKEFILE=ON -DSDBUSCPP_INSTALL=ON -DBUILD_TESTS=ON -DSDBUSCPP_BUILD_PERF_TESTS=ON -DSDBUSCPP_BUILD_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
+    - name: configure-release
+      if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-22.04'
+      run: |
+        mkdir build
+        cd build
+        cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo -DCMAKE_INSTALL_PREFIX:PATH=/usr -DCMAKE_CXX_FLAGS="-O3 -DNDEBUG -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DCMAKE_VERBOSE_MAKEFILE=ON -DSDBUSCPP_INSTALL=ON -DSDBUSCPP_BUILD_TESTS=ON -DSDBUSCPP_BUILD_PERF_TESTS=ON -DSDBUSCPP_BUILD_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
     - name: configure-with-embedded-libsystemd
       if: matrix.build == 'embedded-static-libsystemd'
       run: |
         mkdir build
         cd build
-        cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON -DBUILD_LIBSYSTEMD=ON -DLIBSYSTEMD_VERSION=244 ..
+        cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -DCMAKE_VERBOSE_MAKEFILE=ON -DSDBUSCPP_INSTALL=ON -DBUILD_TESTS=ON -DSDBUSCPP_BUILD_PERF_TESTS=ON -DSDBUSCPP_BUILD_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON -DSDBUSCPP_BUILD_LIBSYSTEMD=ON -DSDBUSCPP_LIBSYSTEMD_VERSION=252 ..
     - name: make
       run: |
         cd build
-        cmake --build . -j2
+        cmake --build . -j4
     - name: verify
       run: |
         cd build
         sudo cmake --build . --target install
-        ctest
+        ctest --output-on-failure
     - name: pack
       if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-20.04'
       run: |
@@ -73,10 +92,29 @@ jobs:
         cpack -G DEB
     - name: 'Upload Artifact'
       if: matrix.build == 'shared-libsystemd' && matrix.os == 'ubuntu-20.04' && matrix.compiler == 'g++'
-      uses: actions/upload-artifact@v2
+      uses: actions/upload-artifact@v3
       with:
         name: "debian-packages-${{ matrix.os }}-${{ matrix.compiler }}"
         path: |
           build/sdbus-c++*.deb
           build/sdbus-c++*.ddeb
         retention-days: 10
+  freebsd-build:
+    name: build (freebsd, clang/libc++, basu)
+    runs-on: ubuntu-22.04 # until https://github.com/actions/runner/issues/385
+    steps:
+    - uses: actions/checkout@v2
+    - name: Test in FreeBSD VM
+      uses: vmactions/freebsd-vm@v1
+      with:
+        copyback: false
+        usesh: true
+        prepare: |
+          pkg install -y cmake ninja pkgconf basu expat googletest
+        run: |
+          cmake -B _build -G Ninja -DSDBUSCPP_INSTALL=ON -DBUILD_CODE_GEN=ON -DBUILD_TESTS=ON -DENABLE_PERF_TESTS=ON -DSDBUSCPP_BUILD_STRESS_TESTS=ON
+          cmake --build _build
+          cmake --install _build
+          pkg install -y dbus
+          service dbus onestart
+          ctest --output-on-failure --test-dir _build

CMakeLists.txt

@@ -2,32 +2,109 @@
 # PROJECT INFORMATION
 #-------------------------------
 
-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.14)
 
-project(sdbus-c++ VERSION 1.2.0 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 2.0.0 LANGUAGES C CXX)
 
 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file
 
+# -------------------------------
+# CONFIGURATION OPTIONS
+# -------------------------------
+
+option(SDBUSCPP_BUILD_LIBSYSTEMD "Fetch & build libsystemd static library and make it part of libsdbus-c++, instead of searching for libsystemd in the system" OFF)
+if(SDBUSCPP_BUILD_LIBSYSTEMD)
+    set(SDBUSCPP_LIBSYSTEMD_VERSION "242" CACHE STRING "libsystemd version (>=239) to build and incorporate into libsdbus-c++")
+    set(SDBUSCPP_LIBSYSTEMD_EXTRA_CONFIG_OPTS "" CACHE STRING "Additional configuration options to be passed as-is to libsystemd build system")
+endif()
+option(SDBUSCPP_INSTALL "Enable installation of sdbus-c++ (downstream projects embedding sdbus-c++ may want to turn this OFF)" ON)
+option(SDBUSCPP_BUILD_TESTS "Build tests" OFF)
+if (SDBUSCPP_BUILD_TESTS)
+    option(SDBUSCPP_BUILD_PERF_TESTS "Build also sdbus-c++ performance tests" OFF) # tranferred from tests/cmake
+    option(SDBUSCPP_BUILD_STRESS_TESTS "Build also sdbus-c++ stress tests" OFF) # tranferred from tests/cmake
+    set(SDBUSCPP_TESTS_INSTALL_PATH "tests/${PROJECT_NAME}" CACHE STRING "Specifies where the test binaries will be installed")  # tranferred from tests/cmake
+    set(SDBUSCPP_GOOGLETEST_VERSION 1.10.0 CACHE STRING "Version of gmock library to use") # tranferred from tests/cmake
+    set(SDBUSCPP_GOOGLETEST_GIT_REPO "https://github.com/google/googletest.git" CACHE STRING "A git repo to clone and build googletest from if gmock is not found in the system") # tranferred from tests/cmake
+endif()
+option(SDBUSCPP_BUILD_CODEGEN "Build generator tool for C++ native bindings" OFF)
+option(SDBUSCPP_BUILD_EXAMPLES "Build example programs" OFF)
+option(SDBUSCPP_BUILD_DOCS "Build documentation for sdbus-c++" ON)
+if(SDBUSCPP_BUILD_DOCS)
+    option(SDBUSCPP_BUILD_DOXYGEN_DOCS "Build doxygen documentation for sdbus-c++ API" OFF)
+endif()
+#option(SDBUSCPP_CLANG_TIDY "Co-compile with clang-tidy static analyzer" OFF)
+#option(SDBUSCPP_COVERAGE "Build sdbus-c++ with code coverage instrumentation" OFF)
+# We promote the BUILD_SHARED_LIBS flag to a (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()
+
+message(STATUS "")
+message(STATUS "  *******************************************")
+message(STATUS "  *         SDBUS-C++ CONFIGURATION         *")
+message(STATUS "  *******************************************")
+message(STATUS "")
+message(STATUS "  SDBUSCPP_BUILD_LIBSYSTEMD: ${SDBUSCPP_BUILD_LIBSYSTEMD}")
+if(SDBUSCPP_BUILD_LIBSYSTEMD)
+    message(STATUS "    SDBUSCPP_LIBSYSTEMD_VERSION: ${SDBUSCPP_LIBSYSTEMD_VERSION}")
+    message(STATUS "    SDBUSCPP_LIBSYSTEMD_EXTRA_CONFIG_OPTS: ${SDBUSCPP_LIBSYSTEMD_EXTRA_CONFIG_OPTS}")
+endif()
+message(STATUS "  SDBUSCPP_INSTALL: ${SDBUSCPP_INSTALL}")
+message(STATUS "  SDBUSCPP_BUILD_TESTS: ${SDBUSCPP_BUILD_TESTS}")
+if(SDBUSCPP_BUILD_TESTS)
+    message(STATUS "    SDBUSCPP_BUILD_PERF_TESTS: ${SDBUSCPP_BUILD_PERF_TESTS}")
+    message(STATUS "    SDBUSCPP_BUILD_STRESS_TESTS: ${SDBUSCPP_BUILD_STRESS_TESTS}")
+    message(STATUS "    SDBUSCPP_TESTS_INSTALL_PATH: ${SDBUSCPP_TESTS_INSTALL_PATH}")
+    message(STATUS "    SDBUSCPP_GOOGLETEST_VERSION: ${SDBUSCPP_GOOGLETEST_VERSION}")
+    message(STATUS "    SDBUSCPP_GOOGLETEST_GIT_REPO: ${SDBUSCPP_GOOGLETEST_GIT_REPO}")
+endif()
+message(STATUS "  SDBUSCPP_BUILD_CODEGEN: ${SDBUSCPP_BUILD_CODEGEN}")
+message(STATUS "  SDBUSCPP_BUILD_EXAMPLES: ${SDBUSCPP_BUILD_EXAMPLES}")
+message(STATUS "  SDBUSCPP_BUILD_DOCS: ${SDBUSCPP_BUILD_DOCS}")
+if(SDBUSCPP_BUILD_DOCS)
+    message(STATUS "    SDBUSCPP_BUILD_DOXYGEN_DOCS: ${SDBUSCPP_BUILD_DOXYGEN_DOCS}")
+endif()
+message(STATUS "  BUILD_SHARED_LIBS: ${BUILD_SHARED_LIBS}")
+message(STATUS "")
+
 #-------------------------------
 # PERFORMING CHECKS & PREPARING THE DEPENDENCIES
 #-------------------------------
 
-option(BUILD_LIBSYSTEMD "Build libsystemd static library and incorporate it into libsdbus-c++" OFF)
+set(LIBSYSTEMD_IMPL "systemd")
+set(LIBSYSTEMD_LIB "libsystemd")
 
-if(NOT BUILD_LIBSYSTEMD)
+if(NOT SDBUSCPP_BUILD_LIBSYSTEMD)
     find_package(PkgConfig REQUIRED)
-    pkg_check_modules(Systemd IMPORTED_TARGET GLOBAL libsystemd>=236)
+    pkg_check_modules(Systemd IMPORTED_TARGET GLOBAL libsystemd>=238)
     if(NOT TARGET PkgConfig::Systemd)
-        message(FATAL_ERROR "libsystemd of version at least 236 is required, but was not found "
+        message(WARNING "libsystemd not found, checking for libelogind instead")
+        pkg_check_modules(Systemd IMPORTED_TARGET GLOBAL libelogind>=238)
+        if(TARGET PkgConfig::Systemd)
+            set(LIBSYSTEMD_IMPL "elogind")
+            set(LIBSYSTEMD_LIB "libelogind")
+            string(REPLACE "." ";" VERSION_LIST ${Systemd_VERSION})
+            list(GET VERSION_LIST 0 Systemd_VERSION)
+        else()
+            message(WARNING "libelogind not found, checking for basu instead")
+            pkg_check_modules(Systemd IMPORTED_TARGET GLOBAL basu)
+            set(LIBSYSTEMD_IMPL "basu")
+            set(LIBSYSTEMD_LIB "basu")
+            # https://git.sr.ht/~emersion/basu/commit/d4d185d29a26
+            set(Systemd_VERSION "240")
+        endif()
+    endif()
+    if(NOT TARGET PkgConfig::Systemd)
+        message(FATAL_ERROR "libsystemd of version at least 238 is required, but was not found "
                             "(if you have systemd in your OS, you may want to install package containing pkgconfig "
                             " files for libsystemd library. On Ubuntu, that is libsystemd-dev. "
-                            " Alternatively, you may turn BUILD_LIBSYSTEMD on for sdbus-c++ to download, build "
-                            "and incorporate libsystemd as embedded library within sdbus-c++)")
+                            " Alternatively, you may turn SDBUSCPP_BUILD_LIBSYSTEMD on for sdbus-c++ to download, "
+                            " build and incorporate libsystemd as embedded library within sdbus-c++)")
     endif()
     add_library(Systemd::Libsystemd ALIAS PkgConfig::Systemd)
     string(REGEX MATCHALL "([0-9]+)" SYSTEMD_VERSION_LIST "${Systemd_VERSION}")
-    list(GET SYSTEMD_VERSION_LIST 0 LIBSYSTEMD_VERSION)
-    message(STATUS "Building with libsystemd v${LIBSYSTEMD_VERSION}")
+    list(GET SYSTEMD_VERSION_LIST 0 SDBUSCPP_LIBSYSTEMD_VERSION)
+    message(STATUS "Building with libsystemd v${SDBUSCPP_LIBSYSTEMD_VERSION}")
 else()
     # Build static libsystemd library as an external project
     include(cmake/LibsystemdExternalProject.cmake)
@@ -69,6 +146,8 @@ set(SDBUSCPP_HDR_SRCS
 set(SDBUSCPP_PUBLIC_HDRS
     ${SDBUSCPP_INCLUDE_DIR}/ConvenienceApiClasses.h
     ${SDBUSCPP_INCLUDE_DIR}/ConvenienceApiClasses.inl
+    ${SDBUSCPP_INCLUDE_DIR}/VTableItems.h
+    ${SDBUSCPP_INCLUDE_DIR}/VTableItems.inl
     ${SDBUSCPP_INCLUDE_DIR}/Error.h
     ${SDBUSCPP_INCLUDE_DIR}/IConnection.h
     ${SDBUSCPP_INCLUDE_DIR}/AdaptorInterfaces.h
@@ -98,20 +177,19 @@ set(CMAKE_CXX_STANDARD 17)
 set(SDBUSCPP_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
 set(SDBUSCPP_VERSION "${PROJECT_VERSION}")
 
-# We promote BUILD_SHARED_LIBS flags to (global) option only if we are the main project
-if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR)
-    option(BUILD_SHARED_LIBS "Build shared libraries (.so) instead of static ones (.a)" ON)
-endif()
-
 # Having an object target allows unit tests to reuse already built sources without re-building
 add_library(sdbus-c++-objlib OBJECT ${SDBUSCPP_SRCS})
-target_compile_definitions(sdbus-c++-objlib PRIVATE BUILD_LIB=1 LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
+target_compile_definitions(sdbus-c++-objlib PRIVATE
+    BUILD_LIB=1
+    LIBSYSTEMD_VERSION=${SDBUSCPP_LIBSYSTEMD_VERSION}
+    SDBUS_${LIBSYSTEMD_IMPL}
+    SDBUS_HEADER=<${LIBSYSTEMD_IMPL}/sd-bus.h>)
 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})
+if(BUILD_SHARED_LIBS)
+    set_target_properties(sdbus-c++-objlib PROPERTIES POSITION_INDEPENDENT_CODE ON)
 endif()
-if(BUILD_LIBSYSTEMD)
+if(SDBUSCPP_BUILD_LIBSYSTEMD)
     add_dependencies(sdbus-c++-objlib LibsystemdBuildProject)
 endif()
 target_link_libraries(sdbus-c++-objlib
@@ -129,28 +207,11 @@ set_target_properties(sdbus-c++
                                  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 ${EXPORT_SET}
-        EXPORT sdbus-c++-targets
-        RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT runtime
-        LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT runtime
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT dev
-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${SDBUSCPP_INCLUDE_SUBDIR} COMPONENT dev)
-
 #----------------------------------
 # TESTS
 #----------------------------------
 
-option(BUILD_TESTS "Build and install tests (default OFF)" OFF)
-
-if(BUILD_TESTS)
+if(SDBUSCPP_BUILD_TESTS)
     message(STATUS "Building with tests")
     enable_testing()
     add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/tests")
@@ -160,9 +221,7 @@ endif()
 # UTILS
 #----------------------------------
 
-option(BUILD_CODE_GEN "Build and install interface stub code generator (default OFF)" OFF)
-
-if(BUILD_CODE_GEN)
+if(SDBUSCPP_BUILD_CODEGEN)
     message(STATUS "Building with code generator tool")
     add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/tools")
 endif()
@@ -171,9 +230,7 @@ endif()
 # EXAMPLES
 #----------------------------------
 
-option(BUILD_EXAMPLES "Build example programs (default OFF)" OFF)
-
-if(BUILD_EXAMPLES)
+if(SDBUSCPP_BUILD_EXAMPLES)
     message(STATUS "Building with examples")
     add_subdirectory(examples)
 endif()
@@ -182,13 +239,9 @@ endif()
 # DOCUMENTATION
 #----------------------------------
 
-option(BUILD_DOC "Build documentation for sdbus-c++" ON)
-
-if(BUILD_DOC)
+if(SDBUSCPP_BUILD_DOCS)
     message(STATUS "Building with documentation")
-    option(BUILD_DOXYGEN_DOC "Build doxygen documentation for sdbus-c++ API" OFF)
     add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/docs")
-    install(FILES README README.md NEWS COPYING ChangeLog AUTHORS DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT doc)
 endif()
 
 #----------------------------------
@@ -197,38 +250,58 @@ endif()
 
 include(CMakePackageConfigHelpers)
 
-install(EXPORT sdbus-c++-targets
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++
-        NAMESPACE SDBusCpp::
-        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)
 
-if(BUILD_SHARED_LIBS AND (BUILD_LIBSYSTEMD OR Systemd_LINK_LIBRARIES MATCHES "/libsystemd\.a(;|$)"))
+if(BUILD_SHARED_LIBS AND (SDBUSCPP_BUILD_LIBSYSTEMD OR Systemd_LINK_LIBRARIES MATCHES "/libsystemd\.a(;|$)"))
     set(PKGCONFIG_REQS ".private")
 else()
     set(PKGCONFIG_REQS "")
 endif()
+set(PKGCONFIG_DEPS ${LIBSYSTEMD_LIB})
 configure_file(pkgconfig/sdbus-c++.pc.in pkgconfig/sdbus-c++.pc @ONLY)
-install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/sdbus-c++.pc
-        DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT dev)
 
 #----------------------------------
-# CPack
+# INSTALLATION
 #----------------------------------
+
+if(SDBUSCPP_INSTALL)
+    set(EXPORT_SET sdbus-c++)
+    if(NOT BUILD_SHARED_LIBS)
+        list(APPEND EXPORT_SET "sdbus-c++-objlib")
+    endif()
+    install(TARGETS ${EXPORT_SET}
+            EXPORT sdbus-c++-targets
+            RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT sdbus-c++-runtime
+            LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT sdbus-c++-runtime NAMELINK_COMPONENT sdbus-c++-dev
+            ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT sdbus-c++-dev
+            PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${SDBUSCPP_INCLUDE_SUBDIR} COMPONENT sdbus-c++-dev)
+    install(EXPORT sdbus-c++-targets
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/cmake/sdbus-c++
+            NAMESPACE SDBusCpp::
+            COMPONENT sdbus-c++-dev)
+    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 sdbus-c++-dev)
+    install(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgconfig/sdbus-c++.pc
+            DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig COMPONENT sdbus-c++-dev)
+    if(SDBUSCPP_BUILD_DOCS)
+        install(FILES README README.md NEWS COPYING ChangeLog AUTHORS DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT sdbus-c++-doc)
+    endif()
+endif()
+
+#----------------------------------
+# CPACK
+#----------------------------------
+
 set(CPACK_PACKAGE_VENDOR "Kistler")
-set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "high-level C++ D-Bus library")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "High-level C++ D-Bus library")
 set(CPACK_PACKAGE_CONTACT "info@kistler.com")
 set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
 set(CPACK_COMPONENTS_ALL runtime dev doc)
 set(CPACK_COMPONENT_DEV_DEPENDS "runtime")
-
 # specific for DEB generator
 set(CPACK_DEB_COMPONENT_INSTALL ON)
 set(CPACK_DEBIAN_RUNTIME_DEBUGINFO_PACKAGE ON)

COPYING-LGPL-Exception

@@ -4,7 +4,7 @@ As an additional permission to the GNU Lesser General Public License version
 2.1, the object code form of a "work that uses the Library" may incorporate
 material from a header file that is part of the Library.  You may distribute
 such object code under terms of your choice, provided that:
-    (i)   the header files of the Library have not been modified; and 
+    (i)   the header files of the Library have not been modified; and
     (ii)  the incorporated material is limited to numerical parameters, data
           structure layouts, accessors, macros, inline functions and
           templates; and

ChangeLog

@@ -216,3 +216,36 @@ v1.2.0
 - Add printer for std::chrono in googletest v1.11.0
 - Fix potential undefined behavior in creation of sdbus::Error
 - Additional little fixes and improvements in code, build system, and documentation
+
+v1.3.0
+- Add support for light-weight proxies (proxies without own event loop threads)
+- Extend documentation with explicit mapping between D-Bus and corresponding C++ types
+- Support move semantics in generated adaptor and proxy classes
+- Adaptations for libsystemd v251
+- Fix for proper complete sending of long D-Bus messages by explicitly flushing them
+- Add support for std::future-based async calls
+- Fix race condition in async Proxy::callMethod
+- Fix pseudo-connection static lifetime issue with Phoenix pattern
+- Speed up performance of of serialization of arrays of trivial D-Bus types
+- Make sdbus::Struct a tuple-like class, so it's usable wherever std::tuple is
+- Add support for std::array, std::span and std::unordered_map as additional C++ types for D-Bus array types
+- Add support for libelogind as an addition to libsystemd
+- Add support for std::future-based async methods in codegen tool
+- Additional little fixes and improvements in code, build system, CI, and documentation
+
+v1.4.0
+- Implement API for convenient asynchronous property get/set on the client-side
+- Add support for FreeBSD systems (including support for basu implementation of sd-bus on non-systemd machines)
+- Add support for direct, peer-to-peer connections
+- Add option to create IConnection directly from an underlying sd_bus instance
+- Some additional fixes
+
+v2.0.0
+- A number of breaking changes in API/ABI/behavior and in the generated bindings. See the sdbus-c++ tutorial for the migration notes.
+- Systemd of at least v238 is required to compile sdbus-c++
+- A proper fix for timeout handling
+- Fix for external event loops in which the event loop thread ID was not correctly initialized (now fixed and simplified by not needing the thread ID anymore)
+- Introduce native integration for sd-event
+- Add method to get currently processed message also to `IConnection`
+- `[[nodiscard]]` attribute has been added to relevant API methods.
+- Other simplifications, improvements and fixes springing out from the above refactoring

README.md

@@ -26,11 +26,11 @@ $ sudo cmake --build . --target install
 
 ### CMake configuration flags for sdbus-c++
 
-* `BUILD_CODE_GEN` [boolean]
+* `SDBUSCPP_BUILD_CODEGEN` [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.
+  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 `-DSDBUSCPP_BUILD_CODEGEN=ON` flag to turn on building the code gen.
 
-* `BUILD_DOC` [boolean]
+* `SDBUSCPP_BUILD_DOCS` [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:
 
@@ -38,31 +38,31 @@ $ sudo cmake --build . --target install
 
       Option for building Doxygen documentation of sdbus-c++ API. If enabled, the documentation must still be built explicitly through `cmake --build . --target doc`. Default value: `OFF`. Use `-DBUILD_DOXYGEN_DOC=OFF` to disable searching for Doxygen and building Doxygen documentation of sdbus-c++ API.
 
-* `BUILD_TESTS` [boolean]
+* `SDBUSCPP_BUILD_TESTS` [boolean]
 
   Option for building sdbus-c++ unit and integration tests, invokable by `cmake --build . --target test` (Note: before invoking `cmake --build . --target test`, make sure you copy `tests/integrationtests/files/org.sdbuscpp.integrationtests.conf` file to `/etc/dbus-1/system.d` directory). That incorporates downloading and building static libraries of Google Test. Default value: `OFF`. Use `-DBUILD_TESTS=ON` to enable building the tests. With this option turned on, you may also enable/disable the following options:
 
-    * `ENABLE_PERF_TESTS` [boolean]
+    * `SDBUSCPP_BUILD_PERF_TESTS` [boolean]
 
       Option for building sdbus-c++ performance tests. Default value: `OFF`.
 
-    * `ENABLE_STRESS_TESTS` [boolean]
+    * `SDBUSCPP_BUILD_STRESS_TESTS` [boolean]
 
       Option for building sdbus-c++ stress tests. Default value: `OFF`.
 
-    * `TESTS_INSTALL_PATH` [string]
+    * `SDBUSCPP_TESTS_INSTALL_PATH` [string]
 
-      Path where the test binaries shall get installed. Default value: `/opt/test/bin`.
+      Path where the test binaries shall get installed. Default value: `${CMAKE_INSTALL_PREFIX}/tests/sdbus-c++` (previously: `/opt/test/bin`).
 
-* `BUILD_LIBSYSTEMD` [boolean]
+* `SDBUSCPP_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]
+    * `SDBUSCPP_LIBSYSTEMD_VERSION` [string]
 
       Defines version of systemd to be downloaded, built and integrated into sdbus-c++. Default value: `242`.
 
-    * `LIBSYSTEMD_EXTRA_CONFIG_OPTS` [string]
+    * `SDBUSCPP_LIBSYSTEMD_EXTRA_CONFIG_OPTS` [string]
 
       Additional options to be passed as-is to the libsystemd build system (meson for systemd v242) in its configure step. Can be used for passing e.g. toolchain file path in case of cross builds. Default value: empty.
 
@@ -74,7 +74,7 @@ $ sudo cmake --build . --target install
 
   This is a global CMake flag, promoted in sdbus-c++ project to a CMake option. Use this to control whether sdbus-c++ is built as either a shared or static library. Default value: `ON`.
 
-* `BUILD_EXAMPLES` [boolean]
+* `SDBUSCPP_BUILD_EXAMPLES` [boolean]
 
   Build example programs which are located in the _example_ directory. Examples are not installed. Default value: `OFF`
 
@@ -82,10 +82,10 @@ Dependencies
 ------------
 
 * `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.)
+* `libsystemd`/`libelogind`/`basu` - libraries containing sd-bus implementation that sdbus-c++ is written around. In case of `libsystemd` and `libelogind`, version >= 236 is needed. (In case you have a non-systemd environment, don't worry, see [Solving libsystemd dependency](docs/using-sdbus-c++.md#solving-libsystemd-dependency) for more information.)
 * `googletest` - google unit testing framework, only necessary when building tests, will be downloaded and built automatically.
 * `pkgconfig` - required for sdbus-c++ to be able to find some dependency packages.
-* `expat` - necessary when building xml2cpp code generator (`BUILD_CODE_GEN` option is ON).
+* `expat` - necessary when building the xml2cpp binding code generator (`SDBUSCPP_BUILD_CODEGEN` option is ON).
 
 Licensing
 ---------
@@ -97,7 +97,7 @@ References/documentation
 
 * [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)
+* [D-Bus Specification](https://dbus.freedesktop.org/doc/dbus-specification.html)
 * [sd-bus Overview](http://0pointer.net/blog/the-new-sd-bus-api-of-systemd.html)
 
 Contributing

cmake/LibsystemdExternalProject.cmake

@@ -18,9 +18,6 @@ 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++")
-set(LIBSYSTEMD_EXTRA_CONFIG_OPTS "" CACHE STRING "Additional configuration options to be passed as-is to libsystemd build system")
-
 if(NOT CMAKE_BUILD_TYPE)
     set(LIBSYSTEMD_BUILD_TYPE "plain")
 elseif(CMAKE_BUILD_TYPE STREQUAL "Debug")
@@ -29,24 +26,24 @@ else()
     set(LIBSYSTEMD_BUILD_TYPE "release")
 endif()
 
-if(LIBSYSTEMD_VERSION LESS "239")
+if(SDBUSCPP_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")
+if(SDBUSCPP_LIBSYSTEMD_VERSION GREATER "240")
     set(BUILD_VERSION_H ${NINJA} -C <BINARY_DIR> version.h)
 endif()
 
-message(STATUS "Building with embedded libsystemd v${LIBSYSTEMD_VERSION}")
+message(STATUS "Building with embedded libsystemd v${SDBUSCPP_LIBSYSTEMD_VERSION}")
 
 include(ExternalProject)
 ExternalProject_Add(LibsystemdBuildProject
-                    PREFIX libsystemd-v${LIBSYSTEMD_VERSION}
+                    PREFIX libsystemd-v${SDBUSCPP_LIBSYSTEMD_VERSION}
                     GIT_REPOSITORY    https://github.com/systemd/systemd-stable.git
-                    GIT_TAG           v${LIBSYSTEMD_VERSION}-stable
+                    GIT_TAG           v${SDBUSCPP_LIBSYSTEMD_VERSION}-stable
                     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 -Dselinux=false <SOURCE_DIR> <BINARY_DIR> ${LIBSYSTEMD_EXTRA_CONFIG_OPTS}
+                              COMMAND ${MESON} --prefix=<INSTALL_DIR> --buildtype=${LIBSYSTEMD_BUILD_TYPE} -Drootprefix=<INSTALL_DIR> -Dstatic-libsystemd=pic -Dselinux=false <SOURCE_DIR> <BINARY_DIR> ${SDBUSCPP_LIBSYSTEMD_EXTRA_CONFIG_OPTS}
                     BUILD_COMMAND     ${BUILD_VERSION_H}
                           COMMAND     ${NINJA} -C <BINARY_DIR> libsystemd.a
                     BUILD_ALWAYS      0

docs/CMakeLists.txt

@@ -15,15 +15,19 @@ if(BUILD_DOXYGEN_DOC)
         # workaround bug https://github.com/doxygen/doxygen/pull/6787
         add_custom_command(TARGET doc POST_BUILD
           COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/sdbus-c++-class-diagram.png ${CMAKE_CURRENT_BINARY_DIR}/html/.)
-        
-        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL COMPONENT doc)
     else()
         message(WARNING "Documentation enabled, but Doxygen cannot be found")
     endif()
 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} COMPONENT doc)
+if(SDBUSCPP_INSTALL)
+    install(FILES sdbus-c++-class-diagram.png
+                  sdbus-c++-class-diagram.uml
+                  systemd-dbus-config.md
+                  using-sdbus-c++.md
+            DESTINATION ${CMAKE_INSTALL_DOCDIR} COMPONENT sdbus-c++-doc)
+
+    if (BUILD_DOXYGEN_DOC AND DOXYGEN_FOUND)
+        install(DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html DESTINATION ${CMAKE_INSTALL_DOCDIR} OPTIONAL COMPONENT sdbus-c++-doc)
+    endif()
+endif()

docs/Doxyfile.in

@@ -162,7 +162,7 @@ FULL_PATH_NAMES        = YES
 # will be relative from the directory where doxygen is started.
 # This tag requires that the tag FULL_PATH_NAMES is set to YES.
 
-STRIP_FROM_PATH        =
+STRIP_FROM_PATH        = @PROJECT_SOURCE_DIR@ @PROJECT_BINARY_DIR@
 
 # The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the
 # path mentioned in the documentation of a class, which tells the reader which

examples/CMakeLists.txt

@@ -1,6 +1,12 @@
+# Building examples
 
 add_executable(obj-manager-server org.freedesktop.DBus.ObjectManager/obj-manager-server.cpp)
 target_link_libraries(obj-manager-server sdbus-c++)
 
 add_executable(obj-manager-client org.freedesktop.DBus.ObjectManager/obj-manager-client.cpp)
-target_link_libraries(obj-manager-client sdbus-c++)
+target_link_libraries(obj-manager-client sdbus-c++)
+
+if(SDBUSCPP_INSTALL)
+    install(TARGETS obj-manager-server DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT sdbus-c++-examples)
+    install(TARGETS obj-manager-client DESTINATION ${CMAKE_INSTALL_BINDIR} COMPONENT sdbus-c++-examples)
+endif()

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

@@ -21,28 +21,37 @@ public:
 
 protected:
     Planet1_proxy(sdbus::IProxy& proxy)
-        : proxy_(proxy)
+        : proxy_(&proxy)
     {
     }
 
+    Planet1_proxy(const Planet1_proxy&) = delete;
+    Planet1_proxy& operator=(const Planet1_proxy&) = delete;
+    Planet1_proxy(Planet1_proxy&&) = default;
+    Planet1_proxy& operator=(Planet1_proxy&&) = default;
+
     ~Planet1_proxy() = default;
 
+    void registerProxy()
+    {
+    }
+
 public:
     uint64_t GetPopulation()
     {
         uint64_t result;
-        proxy_.callMethod("GetPopulation").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        proxy_->callMethod("GetPopulation").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
 public:
     std::string Name()
     {
-        return proxy_.getProperty("Name").onInterface(INTERFACE_NAME);
+        return proxy_->getProperty("Name").onInterface(INTERFACE_NAME);
     }
 
 private:
-    sdbus::IProxy& proxy_;
+    sdbus::IProxy* proxy_;
 };
 
 }}} // namespaces

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

@@ -21,14 +21,24 @@ public:
 
 protected:
     Planet1_adaptor(sdbus::IObject& object)
-        : object_(object)
+        : object_(&object)
     {
-        object_.registerMethod("GetPopulation").onInterface(INTERFACE_NAME).withOutputParamNames("population").implementedAs([this](){ return this->GetPopulation(); });
-        object_.registerProperty("Name").onInterface(INTERFACE_NAME).withGetter([this](){ return this->Name(); });
     }
 
+    Planet1_adaptor(const Planet1_adaptor&) = delete;
+    Planet1_adaptor& operator=(const Planet1_adaptor&) = delete;
+    Planet1_adaptor(Planet1_adaptor&&) = default;
+    Planet1_adaptor& operator=(Planet1_adaptor&&) = default;
+
     ~Planet1_adaptor() = default;
 
+    void registerAdaptor()
+    {
+        object_->addVTable( sdbus::registerMethod("GetPopulation").withOutputParamNames("population").implementedAs([this](){ return this->GetPopulation(); })
+                          , sdbus::registerProperty("Name").withGetter([this](){ return this->Name(); })
+                          ).forInterface(INTERFACE_NAME);
+    }
+
 private:
     virtual uint64_t GetPopulation() = 0;
 
@@ -36,7 +46,7 @@ private:
     virtual std::string Name() = 0;
 
 private:
-    sdbus::IObject& object_;
+    sdbus::IObject* object_;
 };
 
 }}} // namespaces

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

@@ -19,11 +19,11 @@
 #include <thread>
 #include <chrono>
 
-class ManagerAdaptor : public sdbus::AdaptorInterfaces< sdbus::ObjectManager_adaptor >
+class ManagerAdaptor : public sdbus::AdaptorInterfaces<sdbus::ObjectManager_adaptor>
 {
 public:
     ManagerAdaptor(sdbus::IConnection& connection, std::string path)
-    : AdaptorInterfaces(connection, std::move(path))
+        : AdaptorInterfaces(connection, std::move(path))
     {
         registerAdaptor();
     }
@@ -34,15 +34,15 @@ public:
     }
 };
 
-class PlanetAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::ExampleManager::Planet1_adaptor,
-                                                sdbus::ManagedObject_adaptor,
-                                                sdbus::Properties_adaptor >
+class PlanetAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::ExampleManager::Planet1_adaptor
+                                                           , sdbus::ManagedObject_adaptor
+                                                           , sdbus::Properties_adaptor >
 {
 public:
-    PlanetAdaptor(sdbus::IConnection& connection, std::string path, std::string name, uint64_t poulation)
-    : AdaptorInterfaces(connection, std::move(path))
-    , m_name(std::move(name))
-    , m_population(poulation)
+    PlanetAdaptor(sdbus::IConnection& connection, std::string path, std::string name, uint64_t population)
+        : AdaptorInterfaces(connection, std::move(path))
+        , m_name(std::move(name))
+        , m_population(population)
     {
         registerAdaptor();
         emitInterfacesAddedSignal({org::sdbuscpp::ExampleManager::Planet1_adaptor::INTERFACE_NAME});
@@ -105,4 +105,4 @@ int main()
     connection->releaseName("org.sdbuscpp.examplemanager");
     connection->leaveEventLoop();
     return 0;
-}
+}

include/sdbus-c++/AdaptorInterfaces.h

@@ -82,9 +82,10 @@ namespace sdbus {
      * 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();`).
+     * In the final adaptor class inherited from AdaptorInterfaces, one needs to make sure:
+     *   1. to call `registerAdaptor();` in the class constructor, and, conversely,
+     *   2. to call `unregisterAdaptor();` in the class destructor,
+     * so that the object API vtable is registered and unregistered at the proper time.
      *
      ***********************************************/
     template <typename... _Interfaces>
@@ -108,15 +109,15 @@ namespace sdbus {
         }
 
         /*!
-         * @brief Finishes adaptor API registration and publishes the adaptor on the bus
+         * @brief Adds object vtable (i.e. D-Bus API) definitions for all interfaces it implements
          *
          * This function must be called in the constructor of the final adaptor class that implements AdaptorInterfaces.
          *
-         * For more information, see underlying @ref IObject::finishRegistration()
+         * See also @ref IObject::addVTable()
          */
         void registerAdaptor()
         {
-            getObject().finishRegistration();
+            (_Interfaces::registerAdaptor(), ...);
         }
 
         /*!
@@ -132,15 +133,17 @@ namespace sdbus {
         }
 
         /*!
-         * @brief Returns object path of the underlying DBus object
+         * @brief Returns reference to the underlying IObject instance
          */
-        const std::string& getObjectPath() const
-        {
-            return getObject().getObjectPath();
-        }
+        using ObjectHolder::getObject;
 
     protected:
         using base_type = AdaptorInterfaces;
+
+        AdaptorInterfaces(const AdaptorInterfaces&) = delete;
+        AdaptorInterfaces& operator=(const AdaptorInterfaces&) = delete;
+        AdaptorInterfaces(AdaptorInterfaces&&) = default;
+        AdaptorInterfaces& operator=(AdaptorInterfaces&&) = default;
         ~AdaptorInterfaces() = default;
     };
 

include/sdbus-c++/ConvenienceApiClasses.h

@@ -29,119 +29,36 @@
 
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/TypeTraits.h>
-#include <sdbus-c++/Flags.h>
-#include <string>
-#include <vector>
-#include <type_traits>
+#include <sdbus-c++/Types.h>
+#include <sdbus-c++/VTableItems.h>
+
 #include <chrono>
 #include <cstdint>
+#include <future>
+#include <map>
+#include <string>
+#include <vector>
 
 // Forward declarations
 namespace sdbus {
     class IObject;
     class IProxy;
-    class Variant;
     class Error;
     class PendingAsyncCall;
 }
 
 namespace sdbus {
 
-    class MethodRegistrator
+    class VTableAdder
     {
     public:
-        MethodRegistrator(IObject& object, const std::string& methodName);
-        MethodRegistrator(MethodRegistrator&& other) = default;
-        ~MethodRegistrator() noexcept(false);
-
-        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();
+        VTableAdder(IObject& object, std::vector<VTableItem> vtable);
+        void forInterface(std::string interfaceName);
+        [[nodiscard]] Slot forInterface(std::string interfaceName, return_slot_t);
 
     private:
         IObject& object_;
-        const std::string& methodName_;
-        std::string interfaceName_;
-        std::string inputSignature_;
-        std::vector<std::string> inputParamNames_;
-        std::string outputSignature_;
-        std::vector<std::string> outputParamNames_;
-        method_callback methodCallback_;
-        Flags flags_;
-        int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
-    };
-
-    class SignalRegistrator
-    {
-    public:
-        SignalRegistrator(IObject& object, const std::string& signalName);
-        SignalRegistrator(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:
-        IObject& object_;
-        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
-    };
-
-    class PropertyRegistrator
-    {
-    public:
-        PropertyRegistrator(IObject& object, const std::string& propertyName);
-        PropertyRegistrator(PropertyRegistrator&& other) = default;
-        ~PropertyRegistrator() noexcept(false);
-
-        PropertyRegistrator& onInterface(std::string interfaceName);
-        template <typename _Function> PropertyRegistrator& withGetter(_Function&& callback);
-        template <typename _Function> PropertyRegistrator& withSetter(_Function&& callback);
-        PropertyRegistrator& markAsDeprecated();
-        PropertyRegistrator& markAsPrivileged();
-        PropertyRegistrator& withUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior);
-
-    private:
-        IObject& object_;
-        const std::string& propertyName_;
-        std::string interfaceName_;
-        std::string propertySignature_;
-        property_get_callback getter_;
-        property_set_callback setter_;
-        Flags flags_;
-        int exceptions_{}; // Number of active exceptions when PropertyRegistrator is constructed
-    };
-
-    class InterfaceFlagsSetter
-    {
-    public:
-        InterfaceFlagsSetter(IObject& object, const std::string& interfaceName);
-        InterfaceFlagsSetter(InterfaceFlagsSetter&& other) = default;
-        ~InterfaceFlagsSetter() noexcept(false);
-
-        InterfaceFlagsSetter& markAsDeprecated();
-        InterfaceFlagsSetter& markAsPrivileged();
-        InterfaceFlagsSetter& withNoReplyMethods();
-        InterfaceFlagsSetter& withPropertyUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior);
-
-    private:
-        IObject& object_;
-        const std::string& interfaceName_;
-        Flags flags_;
-        int exceptions_{}; // Number of active exceptions when InterfaceFlagsSetter is constructed
+        std::vector<VTableItem> vtable_;
     };
 
     class SignalEmitter
@@ -195,6 +112,10 @@ namespace sdbus {
         AsyncMethodInvoker& withTimeout(const std::chrono::duration<_Rep, _Period>& timeout);
         template <typename... _Args> AsyncMethodInvoker& withArguments(_Args&&... args);
         template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
+        // Returned future will be std::future<void> for no (void) D-Bus method return value
+        //                      or std::future<T> for single D-Bus method return value
+        //                      or std::future<std::tuple<...>> for multiple method return values
+        template <typename... _Args> std::future<future_return_t<_Args...>> getResultAsFuture();
 
     private:
         IProxy& proxy_;
@@ -209,6 +130,10 @@ namespace sdbus {
         SignalSubscriber(IProxy& proxy, const std::string& signalName);
         SignalSubscriber& onInterface(std::string interfaceName);
         template <typename _Function> void call(_Function&& callback);
+        template <typename _Function> [[nodiscard]] Slot call(_Function&& callback, return_slot_t);
+
+    private:
+        template <typename _Function> signal_handler makeSignalHandler(_Function&& callback);
 
     private:
         IProxy& proxy_;
@@ -216,42 +141,87 @@ namespace sdbus {
         std::string interfaceName_;
     };
 
-    class SignalUnsubscriber
-    {
-    public:
-        SignalUnsubscriber(IProxy& proxy, const std::string& signalName);
-        void onInterface(std::string interfaceName);
-
-    private:
-        IProxy& proxy_;
-        const std::string& signalName_;
-    };
-
     class PropertyGetter
     {
     public:
         PropertyGetter(IProxy& proxy, const std::string& propertyName);
-        sdbus::Variant onInterface(const std::string& interfaceName);
+        Variant onInterface(const std::string& interfaceName);
 
     private:
         IProxy& proxy_;
         const std::string& propertyName_;
     };
 
+    class AsyncPropertyGetter
+    {
+    public:
+        AsyncPropertyGetter(IProxy& proxy, const std::string& propertyName);
+        AsyncPropertyGetter& onInterface(const std::string& interfaceName);
+        template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
+        std::future<Variant> getResultAsFuture();
+
+    private:
+        IProxy& proxy_;
+        const std::string& propertyName_;
+        const std::string* interfaceName_{};
+    };
+
     class PropertySetter
     {
     public:
         PropertySetter(IProxy& proxy, const std::string& propertyName);
-        PropertySetter& onInterface(std::string interfaceName);
+        PropertySetter& onInterface(const std::string& interfaceName);
         template <typename _Value> void toValue(const _Value& value);
-        void toValue(const sdbus::Variant& value);
+        template <typename _Value> void toValue(const _Value& value, dont_expect_reply_t);
+        void toValue(const Variant& value);
+        void toValue(const Variant& value, dont_expect_reply_t);
 
     private:
         IProxy& proxy_;
         const std::string& propertyName_;
-        std::string interfaceName_;
+        const std::string* interfaceName_{};
     };
 
-}
+    class AsyncPropertySetter
+    {
+    public:
+        AsyncPropertySetter(IProxy& proxy, const std::string& propertyName);
+        AsyncPropertySetter& onInterface(const std::string& interfaceName);
+        template <typename _Value> AsyncPropertySetter& toValue(_Value&& value);
+        AsyncPropertySetter& toValue(Variant value);
+        template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
+        std::future<void> getResultAsFuture();
+
+    private:
+        IProxy& proxy_;
+        const std::string& propertyName_;
+        const std::string* interfaceName_{};
+        Variant value_;
+    };
+
+    class AllPropertiesGetter
+    {
+    public:
+        AllPropertiesGetter(IProxy& proxy);
+        std::map<std::string, Variant> onInterface(const std::string& interfaceName);
+
+    private:
+        IProxy& proxy_;
+    };
+
+    class AsyncAllPropertiesGetter
+    {
+    public:
+        AsyncAllPropertiesGetter(IProxy& proxy);
+        AsyncAllPropertiesGetter& onInterface(const std::string& interfaceName);
+        template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
+        std::future<std::map<std::string, Variant>> getResultAsFuture();
+
+    private:
+        IProxy& proxy_;
+        const std::string* interfaceName_{};
+    };
+
+} // namespace sdbus
 
 #endif /* SDBUS_CXX_CONVENIENCEAPICLASSES_H_ */

include/sdbus-c++/ConvenienceApiClasses.inl

@@ -27,388 +27,40 @@
 #ifndef SDBUS_CPP_CONVENIENCEAPICLASSES_INL_
 #define SDBUS_CPP_CONVENIENCEAPICLASSES_INL_
 
+#include <sdbus-c++/Error.h>
 #include <sdbus-c++/IObject.h>
 #include <sdbus-c++/IProxy.h>
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/MethodResult.h>
-#include <sdbus-c++/Types.h>
 #include <sdbus-c++/TypeTraits.h>
-#include <sdbus-c++/Error.h>
+#include <sdbus-c++/Types.h>
+
+#include <cassert>
+#include <exception>
 #include <string>
 #include <tuple>
-#include <exception>
-#include <cassert>
+#include <type_traits>
 
 namespace sdbus {
 
-    /*** ----------------- ***/
-    /*** MethodRegistrator ***/
-    /*** ----------------- ***/
+    /*** ------------- ***/
+    /***  VTableAdder  ***/
+    /*** ------------- ***/
 
-    inline MethodRegistrator::MethodRegistrator(IObject& object, const std::string& methodName)
+    inline VTableAdder::VTableAdder(IObject& object, std::vector<VTableItem> vtable)
         : object_(object)
-        , methodName_(methodName)
-        , exceptions_(std::uncaught_exceptions())
+        , vtable_(std::move(vtable))
     {
     }
 
-    inline MethodRegistrator::~MethodRegistrator() noexcept(false) // since C++11, destructors must
-    {                                                              // explicitly be allowed to throw
-        // Don't register the method if MethodRegistrator threw an exception in one of its methods
-        if (std::uncaught_exceptions() != exceptions_)
-            return;
-
-        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
-        // shall never happen. I.e. it should not happen that this destructor is directly called
-        // in the stack-unwinding process of another flying exception (which would lead to immediate
-        // termination). It can be called indirectly in the destructor of another object, but that's
-        // fine and safe provided that the caller catches exceptions thrown from here.
-        // Therefore, we can allow registerMethod() to throw even if we are in the destructor.
-        // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
-        // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerMethod( interfaceName_
-                              , std::move(methodName_)
-                              , std::move(inputSignature_)
-                              , std::move(inputParamNames_)
-                              , std::move(outputSignature_)
-                              , std::move(outputParamNames_)
-                              , std::move(methodCallback_)
-                              , std::move(flags_));
-    }
-
-    inline MethodRegistrator& MethodRegistrator::onInterface(std::string interfaceName)
+    inline void VTableAdder::forInterface(std::string interfaceName)
     {
-        interfaceName_ = std::move(interfaceName);
-
-        return *this;
+        object_.addVTable(std::move(interfaceName), std::move(vtable_));
     }
 
-    template <typename _Function>
-    MethodRegistrator& MethodRegistrator::implementedAs(_Function&& callback)
+    [[nodiscard]] inline Slot VTableAdder::forInterface(std::string interfaceName, return_slot_t)
     {
-        inputSignature_ = signature_of_function_input_arguments<_Function>::str();
-        outputSignature_ = signature_of_function_output_arguments<_Function>::str();
-        methodCallback_ = [callback = std::forward<_Function>(callback)](MethodCall call)
-        {
-            // Create a tuple of callback input arguments' types, which will be used
-            // as a storage for the argument values deserialized from the message.
-            tuple_of_function_input_arg_types_t<_Function> inputArgs;
-
-            // Deserialize input arguments from the message into the tuple.
-            call >> inputArgs;
-
-            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);
-
-        return *this;
-    }
-
-    inline MethodRegistrator& MethodRegistrator::markAsPrivileged()
-    {
-        flags_.set(Flags::PRIVILEGED);
-
-        return *this;
-    }
-
-    inline MethodRegistrator& MethodRegistrator::withNoReply()
-    {
-        flags_.set(Flags::METHOD_NO_REPLY);
-
-        return *this;
-    }
-
-    /*** ----------------- ***/
-    /*** SignalRegistrator ***/
-    /*** ----------------- ***/
-
-    inline SignalRegistrator::SignalRegistrator(IObject& object, const std::string& signalName)
-        : object_(object)
-        , signalName_(signalName)
-        , exceptions_(std::uncaught_exceptions())
-    {
-    }
-
-    inline 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;
-
-        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
-        // 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_
-                              , std::move(signalName_)
-                              , std::move(signalSignature_)
-                              , std::move(paramNames_)
-                              , std::move(flags_) );
-    }
-
-    inline SignalRegistrator& SignalRegistrator::onInterface(std::string interfaceName)
-    {
-        interfaceName_ = std::move(interfaceName);
-
-        return *this;
-    }
-
-    template <typename... _Args>
-    inline SignalRegistrator& SignalRegistrator::withParameters()
-    {
-        signalSignature_ = signature_of_function_input_arguments<void(_Args...)>::str();
-
-        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);
-
-        return *this;
-    }
-
-    /*** ------------------- ***/
-    /*** PropertyRegistrator ***/
-    /*** ------------------- ***/
-
-    inline PropertyRegistrator::PropertyRegistrator(IObject& object, const std::string& propertyName)
-        : object_(object)
-        , propertyName_(propertyName)
-        , exceptions_(std::uncaught_exceptions())
-    {
-    }
-
-    inline 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;
-
-        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
-        // 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( interfaceName_
-                                , propertyName_
-                                , propertySignature_
-                                , std::move(getter_)
-                                , std::move(setter_)
-                                , flags_ );
-    }
-
-    inline PropertyRegistrator& PropertyRegistrator::onInterface(std::string interfaceName)
-    {
-        interfaceName_ = std::move(interfaceName);
-
-        return *this;
-    }
-
-    template <typename _Function>
-    inline PropertyRegistrator& PropertyRegistrator::withGetter(_Function&& callback)
-    {
-        static_assert(function_traits<_Function>::arity == 0, "Property getter function must not take any arguments");
-        static_assert(!std::is_void<function_result_t<_Function>>::value, "Property getter function must return property value");
-
-        if (propertySignature_.empty())
-            propertySignature_ = signature_of_function_output_arguments<_Function>::str();
-
-        getter_ = [callback = std::forward<_Function>(callback)](PropertyGetReply& reply)
-        {
-            // Get the propety value and serialize it into the pre-constructed reply message
-            reply << callback();
-        };
-
-        return *this;
-    }
-
-    template <typename _Function>
-    inline PropertyRegistrator& PropertyRegistrator::withSetter(_Function&& callback)
-    {
-        static_assert(function_traits<_Function>::arity == 1, "Property setter function must take one parameter - the property value");
-        static_assert(std::is_void<function_result_t<_Function>>::value, "Property setter function must not return any value");
-
-        if (propertySignature_.empty())
-            propertySignature_ = signature_of_function_input_arguments<_Function>::str();
-
-        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 incoming call message
-            call >> property;
-
-            // Invoke setter with the value
-            callback(property);
-        };
-
-        return *this;
-    }
-
-    inline PropertyRegistrator& PropertyRegistrator::markAsDeprecated()
-    {
-        flags_.set(Flags::DEPRECATED);
-
-        return *this;
-    }
-
-    inline PropertyRegistrator& PropertyRegistrator::markAsPrivileged()
-    {
-        flags_.set(Flags::PRIVILEGED);
-
-        return *this;
-    }
-
-    inline PropertyRegistrator& PropertyRegistrator::withUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior)
-    {
-        flags_.set(behavior);
-
-        return *this;
-    }
-
-    /*** -------------------- ***/
-    /*** InterfaceFlagsSetter ***/
-    /*** -------------------- ***/
-
-    inline InterfaceFlagsSetter::InterfaceFlagsSetter(IObject& object, const std::string& interfaceName)
-        : object_(object)
-        , interfaceName_(interfaceName)
-        , exceptions_(std::uncaught_exceptions())
-    {
-    }
-
-    inline InterfaceFlagsSetter::~InterfaceFlagsSetter() noexcept(false) // since C++11, destructors must
-    {                                                                    // explicitly be allowed to throw
-        // Don't set any flags if InterfaceFlagsSetter threw an exception in one of its methods
-        if (std::uncaught_exceptions() != exceptions_)
-            return;
-
-        // 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(interfaceName_, std::move(flags_));
-    }
-
-    inline InterfaceFlagsSetter& InterfaceFlagsSetter::markAsDeprecated()
-    {
-        flags_.set(Flags::DEPRECATED);
-
-        return *this;
-    }
-
-    inline InterfaceFlagsSetter& InterfaceFlagsSetter::markAsPrivileged()
-    {
-        flags_.set(Flags::PRIVILEGED);
-
-        return *this;
-    }
-
-    inline InterfaceFlagsSetter& InterfaceFlagsSetter::withNoReplyMethods()
-    {
-        flags_.set(Flags::METHOD_NO_REPLY);
-
-        return *this;
-    }
-
-    inline InterfaceFlagsSetter& InterfaceFlagsSetter::withPropertyUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior)
-    {
-        flags_.set(behavior);
-
-        return *this;
+        return object_.addVTable(std::move(interfaceName), std::move(vtable_), return_slot);
     }
 
     /*** ------------- ***/
@@ -580,14 +232,14 @@ namespace sdbus {
     {
         assert(method_.isValid()); // onInterface() must be placed/called prior to this function
 
-        auto asyncReplyHandler = [callback = std::forward<_Function>(callback)](MethodReply& reply, const Error* error)
+        auto asyncReplyHandler = [callback = std::forward<_Function>(callback)](MethodReply reply, std::optional<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.
             tuple_of_function_input_arg_types_t<_Function> args;
 
             // Deserialize input arguments from the message into the tuple (if no error occurred).
-            if (error == nullptr)
+            if (!error)
             {
                 try
                 {
@@ -595,19 +247,41 @@ namespace sdbus {
                 }
                 catch (const Error& e)
                 {
-                    // Catch message unpack exceptions and pass them to the callback
-                    // in the expected manner to avoid propagating them up the call
-                    // stack to the event loop.
-                    sdbus::apply(callback, &e, args);
+                    // Pass message deserialization exceptions to the client via callback error parameter,
+                    // instead of propagating them up the message loop call stack.
+                    sdbus::apply(callback, e, args);
                     return;
                 }
             }
 
             // Invoke callback with input arguments from the tuple.
-            sdbus::apply(callback, error, args);
+            sdbus::apply(callback, std::move(error), args);
         };
 
-        return proxy_.callMethod(method_, std::move(asyncReplyHandler), timeout_);
+        return proxy_.callMethodAsync(method_, std::move(asyncReplyHandler), timeout_);
+    }
+
+    template <typename... _Args>
+    std::future<future_return_t<_Args...>> AsyncMethodInvoker::getResultAsFuture()
+    {
+        auto promise = std::make_shared<std::promise<future_return_t<_Args...>>>();
+        auto future = promise->get_future();
+
+        uponReplyInvoke([promise = std::move(promise)](std::optional<Error> error, _Args... args)
+        {
+            if (!error)
+                if constexpr (!std::is_void_v<future_return_t<_Args...>>)
+                    promise->set_value({std::move(args)...});
+                else
+                    promise->set_value();
+            else
+                promise->set_exception(std::make_exception_ptr(*std::move(error)));
+        });
+
+        // Will be std::future<void> for no D-Bus method return value
+        //      or std::future<T> for single D-Bus method return value
+        //      or std::future<std::tuple<...>> for multiple method return values
+        return future;
     }
 
     /*** ---------------- ***/
@@ -634,16 +308,33 @@ namespace sdbus {
 
         proxy_.registerSignalHandler( interfaceName_
                                     , signalName_
-                                    , [callback = std::forward<_Function>(callback)](Signal& signal)
+                                    , makeSignalHandler(std::forward<_Function>(callback)) );
+    }
+
+    template <typename _Function>
+    [[nodiscard]] inline Slot SignalSubscriber::call(_Function&& callback, return_slot_t)
+    {
+        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
+
+        return proxy_.registerSignalHandler( interfaceName_
+                                           , signalName_
+                                           , makeSignalHandler(std::forward<_Function>(callback))
+                                           , return_slot );
+    }
+
+    template <typename _Function>
+    inline signal_handler SignalSubscriber::makeSignalHandler(_Function&& callback)
+    {
+        return [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.
             tuple_of_function_input_arg_types_t<_Function> signalArgs;
 
-            // The signal handler can take pure signal parameters only, or an additional `const Error*` as its first
+            // The signal handler can take pure signal parameters only, or an additional `std::optional<Error>` as its first
             // parameter. In the former case, if the deserialization fails (e.g. due to signature mismatch),
             // the failure is ignored (and signal simply dropped). In the latter case, the deserialization failure
-            // will be communicated as a non-zero Error pointer to the client's signal handler.
+            // will be communicated to the client's signal handler as a valid Error object inside the std::optional parameter.
             if constexpr (has_error_param_v<_Function>)
             {
                 // Deserialize input arguments from the signal message into the tuple
@@ -653,12 +344,14 @@ namespace sdbus {
                 }
                 catch (const sdbus::Error& e)
                 {
-                    // Invoke callback with error argument and input arguments from the tuple.
-                    sdbus::apply(callback, &e, signalArgs);
+                    // Pass message deserialization exceptions to the client via callback error parameter,
+                    // instead of propagating them up the message loop call stack.
+                    sdbus::apply(callback, e, signalArgs);
+                    return;
                 }
 
                 // Invoke callback with no error and input arguments from the tuple.
-                sdbus::apply(callback, nullptr, signalArgs);
+                sdbus::apply(callback, {}, signalArgs);
             }
             else
             {
@@ -668,22 +361,7 @@ namespace sdbus {
                 // Invoke callback with input arguments from the tuple.
                 sdbus::apply(callback, signalArgs);
             }
-        });
-    }
-
-    /*** ------------------ ***/
-    /*** SignalUnsubscriber ***/
-    /*** ------------------ ***/
-
-    inline SignalUnsubscriber::SignalUnsubscriber(IProxy& proxy, const std::string& signalName)
-        : proxy_(proxy)
-        , signalName_(signalName)
-    {
-    }
-
-    inline void SignalUnsubscriber::onInterface(std::string interfaceName)
-    {
-        proxy_.unregisterSignalHandler(interfaceName, signalName_);
+        };
     }
 
     /*** -------------- ***/
@@ -696,17 +374,56 @@ namespace sdbus {
     {
     }
 
-    inline sdbus::Variant PropertyGetter::onInterface(const std::string& interfaceName)
+    inline Variant PropertyGetter::onInterface(const std::string& interfaceName)
     {
-        sdbus::Variant var;
-        proxy_
-            .callMethod("Get")
-            .onInterface("org.freedesktop.DBus.Properties")
-            .withArguments(interfaceName, propertyName_)
-            .storeResultsTo(var);
+        Variant var;
+        proxy_.callMethod("Get")
+              .onInterface("org.freedesktop.DBus.Properties")
+              .withArguments(interfaceName, propertyName_)
+              .storeResultsTo(var);
         return var;
     }
 
+    /*** ------------------- ***/
+    /*** AsyncPropertyGetter ***/
+    /*** ------------------- ***/
+
+    inline AsyncPropertyGetter::AsyncPropertyGetter(IProxy& proxy, const std::string& propertyName)
+            : proxy_(proxy)
+            , propertyName_(propertyName)
+    {
+    }
+
+    inline AsyncPropertyGetter& AsyncPropertyGetter::onInterface(const std::string& interfaceName)
+    {
+        interfaceName_ = &interfaceName;
+
+        return *this;
+    }
+
+    template <typename _Function>
+    PendingAsyncCall AsyncPropertyGetter::uponReplyInvoke(_Function&& callback)
+    {
+        static_assert(std::is_invocable_r_v<void, _Function, std::optional<Error>, Variant>, "Property get callback function must accept std::optional<Error> and property value as Variant");
+
+        assert(interfaceName_ != nullptr); // onInterface() must be placed/called prior to this function
+
+        return proxy_.callMethodAsync("Get")
+                     .onInterface("org.freedesktop.DBus.Properties")
+                     .withArguments(*interfaceName_, propertyName_)
+                     .uponReplyInvoke(std::forward<_Function>(callback));
+    }
+
+    inline std::future<Variant> AsyncPropertyGetter::getResultAsFuture()
+    {
+        assert(interfaceName_ != nullptr); // onInterface() must be placed/called prior to this function
+
+        return proxy_.callMethodAsync("Get")
+                     .onInterface("org.freedesktop.DBus.Properties")
+                     .withArguments(*interfaceName_, propertyName_)
+                     .getResultAsFuture<Variant>();
+    }
+
     /*** -------------- ***/
     /*** PropertySetter ***/
     /*** -------------- ***/
@@ -717,9 +434,9 @@ namespace sdbus {
     {
     }
 
-    inline PropertySetter& PropertySetter::onInterface(std::string interfaceName)
+    inline PropertySetter& PropertySetter::onInterface(const std::string& interfaceName)
     {
-        interfaceName_ = std::move(interfaceName);
+        interfaceName_ = &interfaceName;
 
         return *this;
     }
@@ -727,19 +444,146 @@ namespace sdbus {
     template <typename _Value>
     inline void PropertySetter::toValue(const _Value& value)
     {
-        PropertySetter::toValue(sdbus::Variant{value});
+        PropertySetter::toValue(Variant{value});
     }
 
-    inline void PropertySetter::toValue(const sdbus::Variant& value)
+    template <typename _Value>
+    inline void PropertySetter::toValue(const _Value& value, dont_expect_reply_t)
     {
-        assert(!interfaceName_.empty()); // onInterface() must be placed/called prior to this function
-
-        proxy_
-            .callMethod("Set")
-            .onInterface("org.freedesktop.DBus.Properties")
-            .withArguments(interfaceName_, propertyName_, value);
+        PropertySetter::toValue(Variant{value}, dont_expect_reply);
     }
 
-}
+    inline void PropertySetter::toValue(const Variant& value)
+    {
+        assert(interfaceName_ != nullptr); // onInterface() must be placed/called prior to this function
+
+        proxy_.callMethod("Set")
+              .onInterface("org.freedesktop.DBus.Properties")
+              .withArguments(*interfaceName_, propertyName_, value);
+    }
+
+    inline void PropertySetter::toValue(const Variant& value, dont_expect_reply_t)
+    {
+        assert(interfaceName_ != nullptr); // onInterface() must be placed/called prior to this function
+
+        proxy_.callMethod("Set")
+                .onInterface("org.freedesktop.DBus.Properties")
+                .withArguments(*interfaceName_, propertyName_, value)
+                .dontExpectReply();
+    }
+
+    /*** ------------------- ***/
+    /*** AsyncPropertySetter ***/
+    /*** ------------------- ***/
+
+    inline AsyncPropertySetter::AsyncPropertySetter(IProxy& proxy, const std::string& propertyName)
+            : proxy_(proxy)
+            , propertyName_(propertyName)
+    {
+    }
+
+    inline AsyncPropertySetter& AsyncPropertySetter::onInterface(const std::string& interfaceName)
+    {
+        interfaceName_ = &interfaceName;
+
+        return *this;
+    }
+
+    template <typename _Value>
+    inline AsyncPropertySetter& AsyncPropertySetter::toValue(_Value&& value)
+    {
+        return AsyncPropertySetter::toValue(Variant{std::forward<_Value>(value)});
+    }
+
+    inline AsyncPropertySetter& AsyncPropertySetter::toValue(Variant value)
+    {
+        value_ = std::move(value);
+
+        return *this;
+    }
+
+    template <typename _Function>
+    PendingAsyncCall AsyncPropertySetter::uponReplyInvoke(_Function&& callback)
+    {
+        static_assert(std::is_invocable_r_v<void, _Function, std::optional<Error>>, "Property set callback function must accept std::optional<Error> only");
+
+        assert(interfaceName_ != nullptr); // onInterface() must be placed/called prior to this function
+
+        return proxy_.callMethodAsync("Set")
+                     .onInterface("org.freedesktop.DBus.Properties")
+                     .withArguments(*interfaceName_, propertyName_, std::move(value_))
+                     .uponReplyInvoke(std::forward<_Function>(callback));
+    }
+
+    inline std::future<void> AsyncPropertySetter::getResultAsFuture()
+    {
+        assert(interfaceName_ != nullptr); // onInterface() must be placed/called prior to this function
+
+        return proxy_.callMethodAsync("Set")
+                     .onInterface("org.freedesktop.DBus.Properties")
+                     .withArguments(*interfaceName_, propertyName_, std::move(value_))
+                     .getResultAsFuture<>();
+    }
+
+    /*** ------------------- ***/
+    /*** AllPropertiesGetter ***/
+    /*** ------------------- ***/
+
+    inline AllPropertiesGetter::AllPropertiesGetter(IProxy& proxy)
+            : proxy_(proxy)
+    {
+    }
+
+    inline std::map<std::string, Variant> AllPropertiesGetter::onInterface(const std::string& interfaceName)
+    {
+        std::map<std::string, Variant> props;
+        proxy_.callMethod("GetAll")
+                .onInterface("org.freedesktop.DBus.Properties")
+                .withArguments(interfaceName)
+                .storeResultsTo(props);
+        return props;
+    }
+
+    /*** ------------------------ ***/
+    /*** AsyncAllPropertiesGetter ***/
+    /*** ------------------------ ***/
+
+    inline AsyncAllPropertiesGetter::AsyncAllPropertiesGetter(IProxy& proxy)
+            : proxy_(proxy)
+    {
+    }
+
+    inline AsyncAllPropertiesGetter& AsyncAllPropertiesGetter::onInterface(const std::string& interfaceName)
+    {
+        interfaceName_ = &interfaceName;
+
+        return *this;
+    }
+
+    template <typename _Function>
+    PendingAsyncCall AsyncAllPropertiesGetter::uponReplyInvoke(_Function&& callback)
+    {
+        static_assert( std::is_invocable_r_v<void, _Function, std::optional<Error>, std::map<std::string, Variant>>
+                     , "All properties get callback function must accept std::optional<Error< and a map of property names to their values" );
+
+        assert(interfaceName_ != nullptr); // onInterface() must be placed/called prior to this function
+
+        return proxy_.callMethodAsync("GetAll")
+                     .onInterface("org.freedesktop.DBus.Properties")
+                     .withArguments(*interfaceName_)
+                     .uponReplyInvoke(std::forward<_Function>(callback));
+    }
+
+    inline std::future<std::map<std::string, Variant>> AsyncAllPropertiesGetter::getResultAsFuture()
+    {
+        assert(interfaceName_ != nullptr); // onInterface() must be placed/called prior to this function
+
+        return proxy_.callMethodAsync("GetAll")
+                     .onInterface("org.freedesktop.DBus.Properties")
+                     .withArguments(*interfaceName_)
+                     .getResultAsFuture<std::map<std::string, Variant>>();
+    }
+
+} // namespace sdbus
 
 #endif /* SDBUS_CPP_CONVENIENCEAPICLASSES_INL_ */

include/sdbus-c++/Error.h

@@ -55,17 +55,17 @@ namespace sdbus {
         {
         }
 
-        const std::string& getName() const
+        [[nodiscard]] const std::string& getName() const
         {
             return name_;
         }
 
-        const std::string& getMessage() const
+        [[nodiscard]] const std::string& getMessage() const
         {
             return message_;
         }
 
-        bool isValid() const
+        [[nodiscard]] bool isValid() const
         {
             return !getName().empty();
         }
@@ -76,6 +76,8 @@ namespace sdbus {
     };
 
     sdbus::Error createError(int errNo, const std::string& customMsg);
+
+    inline const char* SDBUSCPP_ERROR_NAME = "org.sdbuscpp.Error";
 }
 
 #define SDBUS_THROW_ERROR(_MSG, _ERRNO)                         \

include/sdbus-c++/Flags.h

@@ -74,26 +74,26 @@ namespace sdbus {
             flags_.set(flag, value);
         }
 
-        bool test(GeneralFlags flag) const
+        [[nodiscard]] bool test(GeneralFlags flag) const
         {
             return flags_.test(flag);
         }
 
-        bool test(PropertyUpdateBehaviorFlags flag) const
+        [[nodiscard]] bool test(PropertyUpdateBehaviorFlags flag) const
         {
             return flags_.test(flag);
         }
 
-        uint64_t toSdBusInterfaceFlags() const;
-        uint64_t toSdBusMethodFlags() const;
-        uint64_t toSdBusSignalFlags() const;
-        uint64_t toSdBusPropertyFlags() const;
-        uint64_t toSdBusWritablePropertyFlags() const;
+        [[nodiscard]] uint64_t toSdBusInterfaceFlags() const;
+        [[nodiscard]] uint64_t toSdBusMethodFlags() const;
+        [[nodiscard]] uint64_t toSdBusSignalFlags() const;
+        [[nodiscard]] uint64_t toSdBusPropertyFlags() const;
+        [[nodiscard]] uint64_t toSdBusWritablePropertyFlags() const;
 
     private:
         std::bitset<FLAG_COUNT> flags_;
     };
-    
+
 }
 
 #endif /* SDBUS_CXX_FLAGS_H_ */

include/sdbus-c++/IConnection.h

@@ -28,11 +28,18 @@
 #define SDBUS_CXX_ICONNECTION_H_
 
 #include <sdbus-c++/TypeTraits.h>
-#include <string>
-#include <memory>
+
 #include <chrono>
 #include <cstdint>
+#include <memory>
 #include <optional>
+#include <string>
+
+struct sd_bus;
+struct sd_event;
+namespace sdbus {
+  class Message;
+}
 
 namespace sdbus {
 
@@ -49,62 +56,7 @@ namespace sdbus {
     class IConnection
     {
     public:
-        /*!
-         * Poll Data for external event loop implementations.
-         *
-         * To integrate sdbus with your app's own custom event handling system
-         * you can use this method to query which file descriptors, poll events
-         * and timeouts you should add to your app's poll(2), or select(2)
-         * call in your main event loop.
-         *
-         * If you are unsure what this all means then use
-         * enterEventLoop() or enterEventLoopAsync() instead.
-         *
-         * See: getEventLoopPollData()
-         */
-        struct PollData
-        {
-            /*!
-             * The read fd to be monitored by the event loop.
-             */
-            int fd;
-            /*!
-             * The events to use for poll(2) alongside fd.
-             */
-            short int events;
-
-            /*!
-             * Absolute timeout value in micro seconds and based of CLOCK_MONOTONIC.
-             */
-            uint64_t timeout_usec;
-
-            /*!
-             * Get the event poll timeout.
-             *
-             * The timeout is an absolute value based of CLOCK_MONOTONIC.
-             *
-             * @return a duration since the CLOCK_MONOTONIC epoch started.
-             */
-            [[nodiscard]] std::chrono::microseconds getAbsoluteTimeout() const
-            {
-                return std::chrono::microseconds(timeout_usec);
-            }
-
-            /*!
-             * Get the timeout as relative value from now
-             *
-             * @return std::nullopt if the timeout is indefinite. A duration otherwise.
-             */
-            [[nodiscard]] std::optional<std::chrono::microseconds> getRelativeTimeout() const;
-
-            /*!
-             * Get a converted, relative timeout which can be passed as argument 'timeout' to poll(2)
-             *
-             * @return -1 if the timeout is indefinite. 0 if the poll(2) shouldn't block. An integer in milli
-             * seconds otherwise.
-             */
-            [[nodiscard]] int getPollTimeout() const;
-        };
+        struct PollData;
 
         virtual ~IConnection() = default;
 
@@ -127,11 +79,11 @@ namespace sdbus {
         virtual void releaseName(const std::string& name) = 0;
 
         /*!
-         * @brief Retrieve the unique name of a connection. E.g. ":1.xx"
+         * @brief Retrieves the unique name of a connection. E.g. ":1.xx"
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual std::string getUniqueName() const = 0;
+        [[nodiscard]] virtual std::string getUniqueName() const = 0;
 
         /*!
          * @brief Enters I/O event loop on this bus connection
@@ -161,61 +113,103 @@ namespace sdbus {
         virtual void leaveEventLoop() = 0;
 
         /*!
-         * @brief Adds an ObjectManager at the specified D-Bus object path
+         * @brief Attaches the bus connection to an sd-event event loop
          *
-         * Creates an ObjectManager interface at the specified object path on
-         * the connection. This is a convenient way to interrogate a connection
-         * to see what objects it has.
-         *
-         * This call creates a floating registration. The ObjectManager will
-         * be there for the object path until the connection is destroyed.
-         *
-         * Another, recommended way to add object managers is directly through
-         * IObject API.
+         * @param[in] event sd-event event loop object
+         * @param[in] priority Specified priority
          *
          * @throws sdbus::Error in case of failure
+         *
+         * See `man sd_bus_attach_event'.
          */
-        [[deprecated("Use one of other addObjectManager overloads")]] virtual void addObjectManager(const std::string& objectPath) = 0;
+        virtual void attachSdEventLoop(sd_event *event, int priority = 0) = 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.
+         * @brief Detaches the bus connection from an sd-event event loop
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual PollData getEventLoopPollData() const = 0;
+        virtual void detachSdEventLoop() = 0;
 
         /*!
-         * @brief Process a pending request
+         * @brief Gets current sd-event event loop for the bus connection
          *
-         * @returns true if an event was processed, false if poll should be called
+         * @return Pointer to event loop object if attached, nullptr otherwise
+         */
+        virtual sd_event *getSdEventLoop() = 0;
+
+        /*!
+         * @brief Returns fd's, I/O events and timeout data to be used in an external event loop
          *
-         * 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.
+         * This function is useful to hook up a bus connection object with an
+         * external (like GMainLoop, boost::asio, etc.) or manual event loop
+         * involving poll() or a similar I/O polling call.
+         *
+         * Before **each** invocation of the I/O polling call, this function
+         * should be invoked. Returned PollData::fd file descriptor should
+         * be polled for the events indicated by PollData::events, and the I/O
+         * call should block for that up to the returned PollData::timeout.
+         *
+         * Additionally, returned PollData::eventFd should be polled for POLLIN
+         * events.
+         *
+         * After each I/O polling call the bus connection needs to process
+         * incoming or outgoing data, by invoking processPendingEvent().
+         *
+         * Note that the returned timeout should be considered only a maximum
+         * sleeping time. It is permissible (and even expected) that shorter
+         * timeouts are used by the calling program, in case other event sources
+         * are polled in the same event loop. Note that the returned time-value
+         * is absolute, based of CLOCK_MONOTONIC and specified in microseconds.
+         * Use PollData::getPollTimeout() to have the timeout value converted
+         * in a form that can be passed to poll(2).
+         *
+         * The bus connection conveniently integrates sd-event event loop.
+         * To attach the bus connection to an sd-event event loop, use
+         * attachSdEventLoop() function.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual bool processPendingRequest() = 0;
+        [[nodiscard]] virtual PollData getEventLoopPollData() const = 0;
+
+        /*!
+         * @brief Processes a pending event
+         *
+         * @returns True if an event was processed, false if no operations were pending
+         *
+         * This function drives the D-Bus connection. It processes pending I/O events.
+         * Queued outgoing messages (or parts thereof) are sent out. Queued incoming
+         * messages are dispatched to registered callbacks. Timeouts are recalculated.
+         *
+         * It returns false when no operations were pending and true if a message was
+         * processed. When false is returned the caller should synchronously poll for
+         * I/O events before calling into processPendingEvent() again.
+         * Don't forget to call getEventLoopPollData() each time before the next poll.
+         *
+         * You don't need to directly call this method or getEventLoopPollData() method
+         * when using convenient, internal bus connection event loops through
+         * enterEventLoop() or enterEventLoopAsync() calls, or when the bus is
+         * connected to an sd-event event loop through attachSdEventLoop().
+         * It is invoked automatically when necessary.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual bool processPendingEvent() = 0;
+
+        /*!
+         * @brief Provides access to the currently processed D-Bus message
+         *
+         * This method provides access to the currently processed incoming D-Bus message.
+         * "Currently processed" means that the registered callback handler(s) for that message
+         * are being invoked. This method is meant to be called from within a callback handler
+         * (e.g. from a D-Bus signal handler, or async method reply handler, etc.). In such a case it is
+         * guaranteed to return a valid D-Bus message instance for which the handler is called.
+         * If called from other contexts/threads, it may return a valid or invalid message, depending
+         * on whether a message was processed or not at the time of the call.
+         *
+         * @return Currently processed D-Bus message
+         */
+        [[nodiscard]] virtual Message getCurrentlyProcessedMessage() const = 0;
 
         /*!
          * @brief Sets general method call timeout
@@ -246,7 +240,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual uint64_t getMethodCallTimeout() const = 0;
+        [[nodiscard]] virtual uint64_t getMethodCallTimeout() const = 0;
 
         /*!
          * @brief Adds an ObjectManager at the specified D-Bus object path
@@ -266,17 +260,17 @@ namespace sdbus {
         virtual void addObjectManager(const std::string& objectPath, floating_slot_t) = 0;
 
         /*!
-         * @brief Adds a match rule for incoming message dispatching
+         * @brief Installs a match rule for messages received on this bus connection
          *
          * @param[in] match Match expression to filter incoming D-Bus message
-         * @param[in] callback Callback handler to be called upon incoming D-Bus message matching the rule
+         * @param[in] callback Callback handler to be called upon processing an inbound D-Bus message matching the rule
          * @return RAII-style slot handle representing the ownership of the subscription
          *
          * The method installs a match rule for messages received on the specified bus connection.
          * The syntax of the match rule expression passed in match is described in the D-Bus specification.
          * The specified handler function callback is called for each incoming message matching the specified
          * expression. The match is installed synchronously when connected to a bus broker, i.e. the call
-         * sends a control message requested the match to be added to the broker and waits until the broker
+         * sends a control message requesting the match to be added to the broker and waits until the broker
          * confirms the match has been installed successfully.
          *
          * Simply let go of the slot instance to uninstall the match rule from the bus connection. The slot
@@ -289,11 +283,10 @@ namespace sdbus {
         [[nodiscard]] virtual Slot addMatch(const std::string& match, message_handler callback) = 0;
 
         /*!
-         * @brief Adds a floating match rule for incoming message dispatching
+         * @brief Installs a floating match rule for messages received on this bus connection
          *
          * @param[in] match Match expression to filter incoming D-Bus message
-         * @param[in] callback Callback handler to be called upon incoming D-Bus message matching the rule
-         * @param[in] Floating slot tag
+         * @param[in] callback Callback handler to be called upon processing an inbound D-Bus message matching the rule
          *
          * The method installs a floating match rule for messages received on the specified bus connection.
          * Floating means that the bus connection object owns the match rule, i.e. lifetime of the match rule
@@ -307,32 +300,92 @@ namespace sdbus {
         virtual void addMatch(const std::string& match, message_handler callback, floating_slot_t) = 0;
 
         /*!
-         * @copydoc IConnection::enterEventLoop()
+         * @brief Asynchronously installs a match rule for messages received on this bus connection
          *
-         * @deprecated This function has been replaced by enterEventLoop()
+         * @param[in] match Match expression to filter incoming D-Bus message
+         * @param[in] callback Callback handler to be called upon processing an inbound D-Bus message matching the rule
+         * @param[in] installCallback Callback handler to be called upon processing an inbound D-Bus message matching the rule
+         * @return RAII-style slot handle representing the ownership of the subscription
+         *
+         * This method operates the same as `addMatch()` above, just that it installs the match rule asynchronously,
+         * in a non-blocking fashion. A request is sent to the broker, but the call does not wait for a response.
+         * The `installCallback' callable is called when the response is later received, with the response message
+         * from the broker as parameter. If it's an empty function object, a default implementation is used that
+         * terminates the bus connection should installing the match fail.
+         *
+         * Refer to the @c addMatch(const std::string& match, message_handler callback) documentation, and consult
+         * `man sd_bus_add_match`, for more information.
+         *
+         * @throws sdbus::Error in case of failure
          */
-        [[deprecated("This function has been replaced by enterEventLoop()")]] void enterProcessingLoop();
+        [[nodiscard]] virtual Slot addMatchAsync(const std::string& match, message_handler callback, message_handler installCallback) = 0;
 
         /*!
-         * @copydoc IConnection::enterProcessingLoopAsync()
+         * @brief Asynchronously installs a floating match rule for messages received on this bus connection
          *
-         * @deprecated This function has been replaced by enterEventLoopAsync()
+         * @param[in] match Match expression to filter incoming D-Bus message
+         * @param[in] callback Callback handler to be called upon processing an inbound D-Bus message matching the rule
+         * @param[in] installCallback Callback handler to be called upon processing an inbound D-Bus message matching the rule
+         *
+         * The method installs a floating match rule for messages received on the specified bus connection.
+         * Floating means that the bus connection object owns the match rule, i.e. lifetime of the match rule
+         * is bound to the lifetime of the bus connection.
+         *
+         * Refer to the @c addMatch(const std::string& match, message_handler callback, message_handler installCallback)
+         * documentation for more information.
+         *
+         * @throws sdbus::Error in case of failure
          */
-        [[deprecated("This function has been replaced by enterEventLoopAsync()")]] void enterProcessingLoopAsync();
+        virtual void addMatchAsync(const std::string& match, message_handler callback, message_handler installCallback, floating_slot_t) = 0;
 
         /*!
-         * @copydoc IConnection::leaveProcessingLoop()
+         * @struct PollData
          *
-         * @deprecated This function has been replaced by leaveEventLoop()
+         * Carries poll data needed for integration with external event loop implementations.
+         *
+         * See getEventLoopPollData() for more info.
          */
-        [[deprecated("This function has been replaced by leaveEventLoop()")]] void leaveProcessingLoop();
+        struct PollData
+        {
+            /*!
+             * The read fd to be monitored by the event loop.
+             */
+            int fd;
 
-        /*!
-         * @copydoc IConnection::getProcessLoopPollData()
-         *
-         * @deprecated This function has been replaced by getEventLoopPollData()
-         */
-        [[deprecated("This function has been replaced by getEventLoopPollData()")]] PollData getProcessLoopPollData() const;
+            /*!
+             * The events to use for poll(2) alongside fd.
+             */
+            short int events;
+
+            /*!
+             * Absolute timeout value in microseconds, based of CLOCK_MONOTONIC.
+             *
+             * Call getPollTimeout() to get timeout recalculated to relative timeout that can be passed to poll(2).
+             */
+            std::chrono::microseconds timeout;
+
+            /*!
+             * An additional event fd to be monitored by the event loop for POLLIN events.
+             */
+            int eventFd;
+
+            /*!
+             * Returns the timeout as relative value from now.
+             *
+             * Returned value is std::chrono::microseconds::max() if the timeout is indefinite.
+             *
+             * @return Relative timeout as a time duration
+             */
+            [[nodiscard]] std::chrono::microseconds getRelativeTimeout() const;
+
+            /*!
+             * Returns relative timeout in the form which can be passed as argument 'timeout' to poll(2)
+             *
+             * @return -1 if the timeout is indefinite. 0 if the poll(2) shouldn't block.
+             *         An integer in milliseconds otherwise.
+             */
+            [[nodiscard]] int getPollTimeout() const;
+        };
     };
 
     template <typename _Rep, typename _Period>
@@ -342,45 +395,6 @@ namespace sdbus {
         return setMethodCallTimeout(microsecs.count());
     }
 
-    inline void IConnection::enterProcessingLoop()
-    {
-        enterEventLoop();
-    }
-
-    inline void IConnection::enterProcessingLoopAsync()
-    {
-        enterEventLoopAsync();
-    }
-
-    inline void IConnection::leaveProcessingLoop()
-    {
-        leaveEventLoop();
-    }
-
-    inline IConnection::PollData IConnection::getProcessLoopPollData() const
-    {
-        return getEventLoopPollData();
-    }
-
-    /*!
-     * @brief Creates/opens D-Bus system bus connection
-     *
-     * @return Connection instance
-     *
-     * @throws sdbus::Error in case of failure
-     */
-    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection();
-
-    /*!
-     * @brief Creates/opens D-Bus system bus connection with a name
-     *
-     * @param[in] name Name to request on the connection after its opening
-     * @return Connection instance
-     *
-     * @throws sdbus::Error in case of failure
-     */
-    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name);
-
     /*!
      * @brief Creates/opens D-Bus session bus connection when in a user context, and a system bus connection, otherwise.
      *
@@ -388,7 +402,7 @@ namespace sdbus {
      *
      * @throws sdbus::Error in case of failure
      */
-    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDefaultBusConnection();
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createBusConnection();
 
     /*!
      * @brief Creates/opens D-Bus session bus connection with a name when in a user context, and a system bus connection with a name, otherwise.
@@ -398,7 +412,7 @@ namespace sdbus {
      *
      * @throws sdbus::Error in case of failure
      */
-    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string& name);
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createBusConnection(const std::string& name);
 
     /*!
      * @brief Creates/opens D-Bus system bus connection
@@ -459,6 +473,74 @@ namespace sdbus {
      * @throws sdbus::Error in case of failure
      */
     [[nodiscard]] std::unique_ptr<sdbus::IConnection> createRemoteSystemBusConnection(const std::string& host);
+
+    /*!
+     * @brief Opens direct D-Bus connection at a custom address
+     *
+     * @param[in] address ";"-separated list of addresses of bus brokers to try to connect to
+     * @return Connection instance
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDirectBusConnection(const std::string& address);
+
+    /*!
+     * @brief Opens direct D-Bus connection at the given file descriptor
+     *
+     * @param[in] fd File descriptor used to communicate directly from/to a D-Bus server
+     * @return Connection instance
+     *
+     * The underlying sdbus-c++ connection instance takes over ownership of fd, so the caller can let it go.
+     * If, however, the call throws an exception, the ownership of fd remains with the caller.
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createDirectBusConnection(int fd);
+
+    /*!
+     * @brief Opens direct D-Bus connection at fd as a server
+     *
+     * @param[in] fd File descriptor to use for server DBus connection
+     * @return Server connection instance
+     *
+     * This creates a new, custom bus object in server mode. One can then call createDirectBusConnection()
+     * on client side to connect to this bus.
+     *
+     * The underlying sdbus-c++ connection instance takes over ownership of fd, so the caller can let it go.
+     * If, however, the call throws an exception, the ownership of fd remains with the caller.
+     *
+     * @throws sdbus::Error in case of failure
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createServerBus(int fd);
+
+    /*!
+     * @brief Creates sdbus-c++ bus connection representation out of underlying sd_bus instance
+     *
+     * @param[in] bus File descriptor to use for server DBus connection
+     * @return Connection instance
+     *
+     * This functions is helpful in cases where clients need a custom, tweaked configuration of their
+     * bus object. Since sdbus-c++ does not provide C++ API for all bus connection configuration
+     * functions of the underlying sd-bus library, clients can use these sd-bus functions themselves
+     * to create and configure their sd_bus object, and create sdbus-c++ IConnection on top of it.
+     *
+     * The IConnection instance assumes unique ownership of the provided bus object. The bus object
+     * must have been started by the client before this call.
+     * The bus object will get flushed, closed, and unreffed when the IConnection instance is destroyed.
+     *
+     * @throws sdbus::Error in case of failure
+     *
+     * Code example:
+     * @code
+     * sd_bus* bus{};
+     * ::sd_bus_new(&bus);
+     * ::sd_bus_set_address(bus, address);
+     * ::sd_bus_set_anonymous(bus, true);
+     * ::sd_bus_start(bus);
+     * auto con = sdbus::createBusConnection(bus); // IConnection consumes sd_bus object
+     * @endcode
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IConnection> createBusConnection(sd_bus *bus);
 }
 
 #endif /* SDBUS_CXX_ICONNECTION_H_ */

include/sdbus-c++/IObject.h

@@ -28,11 +28,13 @@
 #define SDBUS_CXX_IOBJECT_H_
 
 #include <sdbus-c++/ConvenienceApiClasses.h>
-#include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Flags.h>
+#include <sdbus-c++/TypeTraits.h>
+#include <sdbus-c++/VTableItems.h>
+
 #include <functional>
-#include <string>
 #include <memory>
+#include <string>
 #include <vector>
 
 // Forward declarations
@@ -62,144 +64,104 @@ namespace sdbus {
         virtual ~IObject() = default;
 
         /*!
-         * @brief Registers method that the object will provide on D-Bus
+         * @brief Adds a declaration of methods, properties and signals of the object at a given interface
          *
-         * @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)
+         * @param[in] interfaceName Name of an interface the the vtable is registered for
+         * @param[in] items Individual instances of VTable item structures
+         *
+         * This method is used to declare attributes for the object under the given interface.
+         * Parameter `items' represents a vtable definition that may contain method declarations
+         * (using MethodVTableItem struct), property declarations (using PropertyVTableItem
+         * struct), signal declarations (using SignalVTableItem struct), or global interface
+         * flags (using InterfaceFlagsVTableItem struct).
+         *
+         * An interface can have any number of vtables attached to it.
+         *
+         * Consult manual pages for underlying `sd_bus_add_object_vtable` function for more information.
+         *
+         * The method can be called at any time during object's lifetime. For each vtable an internal
+         * match slot is created and its lifetime is tied to the lifetime of the Object instance.
+         *
+         * The function provides strong exception guarantee. The state of the object remains
+         * unmodified in face of an exception.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual void registerMethod( const std::string& interfaceName
-                                   , std::string methodName
-                                   , std::string inputSignature
-                                   , std::string outputSignature
-                                   , method_callback methodCallback
-                                   , Flags flags = {} ) = 0;
+        template < typename... VTableItems
+                 , typename = std::enable_if_t<(is_one_of_variants_types<VTableItem, std::decay_t<VTableItems>> && ...)> >
+        void addVTable(std::string interfaceName, VTableItems&&... items);
 
         /*!
-         * @brief Registers method that the object will provide on D-Bus
+         * @brief Adds a declaration of methods, properties and signals of the object at a given interface
          *
-         * @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)
+         * @param[in] interfaceName Name of an interface the the vtable is registered for
+         * @param[in] vtable A list of individual descriptions in the form of VTable item instances
          *
-         * 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.
+         * This method is used to declare attributes for the object under the given interface.
+         * The `vtable' parameter may contain method declarations (using MethodVTableItem struct),
+         * property declarations (using PropertyVTableItem struct), signal declarations (using
+         * SignalVTableItem struct), or global interface flags (using InterfaceFlagsVTableItem struct).
+         *
+         * An interface can have any number of vtables attached to it.
+         *
+         * Consult manual pages for underlying `sd_bus_add_object_vtable` function for more information.
+         *
+         * The method can be called at any time during object's lifetime. For each vtable an internal
+         * match slot is created and its lifetime is tied to the lifetime of the Object instance.
+         *
+         * The function provides strong exception guarantee. The state of the object remains
+         * unmodified in face of an exception.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual void registerMethod( const std::string& interfaceName
-                                   , std::string methodName
-                                   , std::string inputSignature
-                                   , const std::vector<std::string>& inputNames
-                                   , std::string outputSignature
-                                   , const std::vector<std::string>& outputNames
-                                   , method_callback methodCallback
-                                   , Flags flags = {} ) = 0;
+        virtual void addVTable(std::string interfaceName, std::vector<VTableItem> vtable) = 0;
 
         /*!
-         * @brief Registers signal that the object will emit on D-Bus
+         * @brief Adds a declaration of methods, properties and signals of the object at a given interface
          *
-         * @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)
+         * @param[in] interfaceName Name of an interface the the vtable is registered for
+         * @param[in] vtable A list of individual descriptions in the form of VTable item instances
+         *
+         * This method is used to declare attributes for the object under the given interface.
+         * The `vtable' parameter may contain method declarations (using MethodVTableItem struct),
+         * property declarations (using PropertyVTableItem struct), signal declarations (using
+         * SignalVTableItem struct), or global interface flags (using InterfaceFlagsVTableItem struct).
+         *
+         * An interface can have any number of vtables attached to it.
+         *
+         * Consult manual pages for underlying `sd_bus_add_object_vtable` function for more information.
+         *
+         * The method can be called at any time during object's lifetime. For each vtable an internal
+         * match slot is created and is returned to the caller. The returned slot should be destroyed
+         * when the vtable is not needed anymore. This allows for "dynamic" object API where vtables
+         * can be added or removed by the user at runtime.
+         *
+         * The function provides strong exception guarantee. The state of the object remains
+         * unmodified in face of an exception.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual void registerSignal( const std::string& interfaceName
-                                   , std::string signalName
-                                   , std::string signature
-                                   , Flags flags = {} ) = 0;
+        [[nodiscard]] virtual Slot addVTable(std::string interfaceName, std::vector<VTableItem> vtable, return_slot_t) = 0;
 
         /*!
-         * @brief Registers signal that the object will emit on D-Bus
+         * @brief A little more convenient overload of addVTable() above
          *
-         * @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)
+         * This version allows method chaining for a little safer and more readable VTable registration.
          *
-         * 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
+         * See addVTable() overloads above for detailed documentation.
          */
-        virtual void registerSignal( const std::string& interfaceName
-                                   , std::string signalName
-                                   , std::string signature
-                                   , const std::vector<std::string>& paramNames
-                                   , Flags flags = {} ) = 0;
+        template < typename... VTableItems
+                 , typename = std::enable_if_t<(is_one_of_variants_types<VTableItem, std::decay_t<VTableItems>> && ...)> >
+        [[nodiscard]] VTableAdder addVTable(VTableItems&&... items);
 
         /*!
-         * @brief Registers read-only property that the object will provide on D-Bus
+         * @brief A little more convenient overload of addVTable() above
          *
-         * @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)
+         * This version allows method chaining for a little safer and more readable VTable registration.
          *
-         * @throws sdbus::Error in case of failure
+         * See addVTable() overloads above for detailed documentation.
          */
-        virtual void registerProperty( const std::string& interfaceName
-                                     , 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
-         * @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
-                                     , 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
-         */
-        virtual void setInterfaceFlags(const std::string& interfaceName, Flags flags) = 0;
-
-        /*!
-         * @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;
+        [[nodiscard]] VTableAdder addVTable(std::vector<VTableItem> vtable);
 
         /*!
          * @brief Unregisters object's API and removes object from the bus
@@ -226,7 +188,7 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual Signal createSignal(const std::string& interfaceName, const std::string& signalName) = 0;
+        [[nodiscard]] virtual Signal createSignal(const std::string& interfaceName, const std::string& signalName) = 0;
 
         /*!
          * @brief Emits signal for this object path
@@ -239,6 +201,27 @@ namespace sdbus {
          */
         virtual void emitSignal(const sdbus::Signal& message) = 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
+         */
+        [[nodiscard]] SignalEmitter emitSignal(const std::string& signalName);
+
         /*!
          * @brief Emits PropertyChanged signal for specified properties under a given interface of this object path
          *
@@ -276,10 +259,8 @@ namespace sdbus {
          * @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.
+         * of registered interfaces. Since v2.0, sdbus-c++ supports dynamically addable/removable
+         * object interfaces and their vtables, so this method now makes more sense.
          *
          * @throws sdbus::Error in case of failure
          */
@@ -300,10 +281,8 @@ namespace sdbus {
          * @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.
+         * of registered interfaces. Since v2.0, sdbus-c++ supports dynamically addable/removable
+         * object interfaces and their vtables, so this method now makes more sense.
          *
          * @throws sdbus::Error in case of failure
          */
@@ -331,160 +310,60 @@ namespace sdbus {
          * @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;
+        [[nodiscard]] 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);
+        [[nodiscard]] virtual sdbus::IConnection& getConnection() const = 0;
 
         /*!
          * @brief Returns object path of the underlying DBus object
          */
-        virtual const std::string& getObjectPath() const = 0;
+        [[nodiscard]] virtual const std::string& getObjectPath() const = 0;
 
         /*!
-         * @brief Provides currently processed D-Bus message
+         * @brief Provides access to the currently processed D-Bus message
          *
-         * This method provides immutable access to the currently processed incoming D-Bus message.
+         * This method provides access to the currently processed incoming D-Bus message.
          * "Currently processed" means that the registered callback handler(s) for that message
          * are being invoked. This method is meant to be called from within a callback handler
-         * (e.g. D-Bus method implementation handler). In such a case it is guaranteed to return
-         * a valid pointer to the D-Bus message for which the handler is called. If called from other
-         * contexts/threads, it may return a nonzero pointer or a nullptr, depending on whether a message
-         * was processed at the time of call or not, but the value is nondereferencable, since the pointed-to
-         * message may have gone in the meantime.
+         * (e.g. from a D-Bus signal handler, or async method reply handler, etc.). In such a case it is
+         * guaranteed to return a valid D-Bus message instance for which the handler is called.
+         * If called from other contexts/threads, it may return a valid or invalid message, depending
+         * on whether a message was processed or not at the time of the call.
          *
-         * @return A pointer to the currently processed D-Bus message
+         * @return Currently processed D-Bus message
          */
-        virtual const Message* getCurrentlyProcessedMessage() const = 0;
+        [[nodiscard]] virtual Message getCurrentlyProcessedMessage() const = 0;
     };
 
     // Out-of-line member definitions
 
-    inline MethodRegistrator IObject::registerMethod(const std::string& methodName)
-    {
-        return MethodRegistrator(*this, methodName);
-    }
-
-    inline SignalRegistrator IObject::registerSignal(const std::string& signalName)
-    {
-        return SignalRegistrator(*this, signalName);
-    }
-
-    inline PropertyRegistrator IObject::registerProperty(const std::string& propertyName)
-    {
-        return PropertyRegistrator(*this, propertyName);
-    }
-
-    inline InterfaceFlagsSetter IObject::setInterfaceFlags(const std::string& interfaceName)
-    {
-        return InterfaceFlagsSetter(*this, interfaceName);
-    }
-
     inline SignalEmitter IObject::emitSignal(const std::string& signalName)
     {
         return SignalEmitter(*this, signalName);
     }
 
+    template <typename... VTableItems, typename>
+    void IObject::addVTable(std::string interfaceName, VTableItems&&... items)
+    {
+        addVTable(std::move(interfaceName), {std::forward<VTableItems>(items)...});
+    }
+
+    template <typename... VTableItems, typename>
+    VTableAdder IObject::addVTable(VTableItems&&... items)
+    {
+        return addVTable(std::vector<VTableItem>{std::forward<VTableItems>(items)...});
+    }
+
+    inline VTableAdder IObject::addVTable(std::vector<VTableItem> vtable)
+    {
+        return VTableAdder(*this, std::move(vtable));
+    }
+
     /*!
      * @brief Creates instance representing a D-Bus object
      *
@@ -508,5 +387,6 @@ namespace sdbus {
 }
 
 #include <sdbus-c++/ConvenienceApiClasses.inl>
+#include <sdbus-c++/VTableItems.inl>
 
 #endif /* SDBUS_CXX_IOBJECT_H_ */

include/sdbus-c++/IProxy.h

@@ -28,10 +28,13 @@
 #define SDBUS_CXX_IPROXY_H_
 
 #include <sdbus-c++/ConvenienceApiClasses.h>
-#include <string>
-#include <memory>
-#include <functional>
+#include <sdbus-c++/TypeTraits.h>
+
 #include <chrono>
+#include <functional>
+#include <future>
+#include <memory>
+#include <string>
 
 // Forward declarations
 namespace sdbus {
@@ -78,25 +81,34 @@ namespace sdbus {
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;
+        [[nodiscard]] virtual MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;
 
         /*!
-         * @brief Calls method on the proxied D-Bus object
+         * @brief Calls method on the remote 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.
+         * The call does not block if the method call has dont-expect-reply flag set. In that case,
+         * the call returns immediately and the return value is an empty, invalid method reply.
          *
-         * 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).
+         * The call blocks otherwise, waiting for the remote peer to send back a reply or an error,
+         * or until the call times out.
          *
-         * Note: To avoid messing with messages, use higher-level API defined below.
+         * While blocking, other concurrent operations (in other threads) on the underlying bus
+         * connection are stalled until the call returns. This is not an issue in vast majority of
+         * (simple, single-threaded) applications. In asynchronous, multi-threaded designs involving
+         * shared bus connections, this may be an issue. It is advised to instead use an asynchronous
+         * callMethod() function overload, which does not block the bus connection, or do the synchronous
+         * call from another Proxy instance created just before the call and then destroyed (which is
+         * anyway quite a typical approach in D-Bus implementations). Such proxy instance must have
+         * its own bus connection. So-called light-weight proxies (ones created with `dont_run_event_loop_thread`
+         * tag are designed for exactly that purpose.
          *
-         * @throws sdbus::Error in case of failure
+         * Note: To avoid messing with messages, use API on a higher level of abstraction defined below.
+         *
+         * @throws sdbus::Error in case of failure (also in case the remote function returned an error)
          */
         virtual MethodReply callMethod(const MethodCall& message, uint64_t timeout = 0) = 0;
 
@@ -107,76 +119,86 @@ namespace sdbus {
         MethodReply callMethod(const MethodCall& message, const std::chrono::duration<_Rep, _Period>& timeout);
 
         /*!
-         * @brief Calls method on the proxied D-Bus object asynchronously
+         * @brief Calls method on the 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.
+         * This is a callback-based way of asynchronously calling a remote D-Bus method.
          *
-         * Note: To avoid messing with messages, use higher-level API defined below.
+         * The call itself 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 bus
+         * connection I/O event loop thread.
+         *
+         * Note: To avoid messing with messages, use API on a higher level of abstraction defined below.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual PendingAsyncCall callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout = 0) = 0;
+        virtual PendingAsyncCall callMethodAsync( 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);
+        PendingAsyncCall callMethodAsync( 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
+         * @brief Calls method on the D-Bus object asynchronously
          *
-         * @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
+         * @param[in] message Message representing an async method call
+         * @param[in] Tag denoting a std::future-based overload
+         * @return Future object providing access to the future method reply message
+         *
+         * This is a std::future-based way of asynchronously calling a remote D-Bus method.
+         *
+         * The call itself is non-blocking. It doesn't wait for the reply. Once the reply arrives,
+         * the provided future object will be set to contain the reply (or sdbus::Error
+         * in case the remote method threw an exception).
+         *
+         * Note: To avoid messing with messages, use higher-level API defined below.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual void registerSignalHandler( const std::string& interfaceName
-                                          , const std::string& signalName
-                                          , signal_handler signalHandler ) = 0;
+        virtual std::future<MethodReply> callMethodAsync(const MethodCall& message, with_future_t) = 0;
 
         /*!
-         * @brief Unregisters the handler of the desired signal
+         * @brief Calls method on the D-Bus object asynchronously, with custom timeout
          *
-         * @param[in] interfaceName Name of an interface that the signal belongs to
-         * @param[in] signalName Name of the signal
+         * @param[in] message Message representing an async method call
+         * @param[in] timeout Method call timeout
+         * @param[in] Tag denoting a std::future-based overload
+         * @return Future object providing access to the future method reply message
+         *
+         * This is a std::future-based way of asynchronously calling a remote D-Bus method.
+         *
+         * The call itself is non-blocking. It doesn't wait for the reply. Once the reply arrives,
+         * the provided future object will be set to contain the reply (or sdbus::Error
+         * in case the remote method threw an exception, or the call timed out).
+         *
+         * Note: To avoid messing with messages, use higher-level API defined below.
          *
          * @throws sdbus::Error in case of failure
          */
-        virtual void unregisterSignalHandler( const std::string& interfaceName
-                                            , const std::string& signalName ) = 0;
+        virtual std::future<MethodReply> callMethodAsync( const MethodCall& message
+                                                        , uint64_t timeout
+                                                        , with_future_t ) = 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
+         * @copydoc IProxy::callMethod(const MethodCall&,uint64_t,with_future_t)
          */
-        virtual void finishRegistration() = 0;
+        template <typename _Rep, typename _Period>
+        std::future<MethodReply> callMethodAsync( const MethodCall& message
+                                                , const std::chrono::duration<_Rep, _Period>& timeout
+                                                , with_future_t );
 
         /*!
-         * @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
+         * @brief Calls method on the D-Bus object
          *
          * @param[in] methodName Name of the method
          * @return A helper object for convenient invocation of the method
@@ -197,7 +219,7 @@ namespace sdbus {
         [[nodiscard]] MethodInvoker callMethod(const std::string& methodName);
 
         /*!
-         * @brief Calls method on the proxied D-Bus object asynchronously
+         * @brief Calls method on the D-Bus object asynchronously
          *
          * @param[in] methodName Name of the method
          * @return A helper object for convenient asynchronous invocation of the method
@@ -221,7 +243,43 @@ namespace sdbus {
         [[nodiscard]] AsyncMethodInvoker callMethodAsync(const std::string& methodName);
 
         /*!
-         * @brief Registers signal handler for a given signal of the proxied D-Bus object
+         * @brief Registers a handler for the desired signal emitted by the 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
+         *
+         * A signal can be subscribed to and unsubscribed from at any time during proxy
+         * lifetime. The subscription is active immediately after the call.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void registerSignalHandler( const std::string& interfaceName
+                                          , const std::string& signalName
+                                          , signal_handler signalHandler ) = 0;
+
+        /*!
+         * @brief Registers a handler for the desired signal emitted by the 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
+         *
+         * @return RAII-style slot handle representing the ownership of the subscription
+         *
+         * A signal can be subscribed to and unsubscribed from at any time during proxy
+         * lifetime. The subscription is active immediately after the call. The subscription
+         * is unregistered when the client destroys the returned slot object.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] virtual Slot registerSignalHandler( const std::string& interfaceName
+                                                        , const std::string& signalName
+                                                        , signal_handler signalHandler
+                                                        , return_slot_t ) = 0;
+
+        /*!
+         * @brief Registers signal handler for a given signal of the D-Bus object
          *
          * @param[in] signalName Name of the signal
          * @return A helper object for convenient registration of the signal handler
@@ -231,6 +289,9 @@ namespace sdbus {
          * in a message and D-Bus signatures automatically deduced from the parameters
          * of the provided native signal callback.
          *
+         * A signal can be subscribed to and unsubscribed from at any time during proxy
+         * lifetime. The subscription is active immediately after the call.
+         *
          * Example of use:
          * @code
          * object_.uponSignal("fooSignal").onInterface("com.kistler.foo").call([this](int arg1, double arg2){ this->onFooSignal(arg1, arg2); });
@@ -241,24 +302,18 @@ namespace sdbus {
         [[nodiscard]] SignalSubscriber uponSignal(const std::string& signalName);
 
         /*!
-         * @brief Unregisters signal handler of a given signal of the proxied D-Bus object
+         * @brief Unregisters proxy's signal handlers and stops receiving replies to pending async calls
          *
-         * @param[in] signalName Name of the signal
-         * @return A helper object for convenient unregistration of the signal handler
-         *
-         * This is a high-level, convenience way of unregistering a D-Bus signal's handler.
-         *
-         * Example of use:
-         * @code
-         * object_.muteSignal("fooSignal").onInterface("com.kistler.foo");
-         * @endcode
+         * 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
          */
-        [[nodiscard]] SignalUnsubscriber muteSignal(const std::string& signalName);
+        virtual void unregister() = 0;
 
         /*!
-         * @brief Gets value of a property of the proxied D-Bus object
+         * @brief Gets value of a property of the D-Bus object
          *
          * @param[in] propertyName Name of the property
          * @return A helper object for convenient getting of property value
@@ -277,51 +332,128 @@ namespace sdbus {
         [[nodiscard]] PropertyGetter getProperty(const std::string& propertyName);
 
         /*!
-         * @brief Sets value of a property of the proxied D-Bus object
+         * @brief Gets value of a property of the D-Bus object asynchronously
+         *
+         * @param[in] propertyName Name of the property
+         * @return A helper object for convenient asynchronous 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.
+         *
+         * Example of use:
+         * @code
+         * std::future<sdbus::Variant> state = object.getPropertyAsync("state").onInterface("com.kistler.foo").getResultAsFuture();
+         * auto callback = [](std::optional<sdbus::Error> err, const sdbus::Variant& value){ ... };
+         * object.getPropertyAsync("state").onInterface("com.kistler.foo").uponReplyInvoke(std::move(callback));
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] AsyncPropertyGetter getPropertyAsync(const std::string& propertyName);
+
+        /*!
+         * @brief Sets value of a property of the 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.
+         * Setting property value with NoReply flag is also supported.
          *
          * Example of use:
          * @code
          * int state = ...;
          * object_.setProperty("state").onInterface("com.kistler.foo").toValue(state);
+         * // Or we can just send the set message call without waiting for the reply
+         * object_.setProperty("state").onInterface("com.kistler.foo").toValue(state, dont_expect_reply);
          * @endcode
          *
          * @throws sdbus::Error in case of failure
          */
         [[nodiscard]] PropertySetter setProperty(const std::string& propertyName);
 
+        /*!
+         * @brief Sets value of a property of the D-Bus object asynchronously
+         *
+         * @param[in] propertyName Name of the property
+         * @return A helper object for convenient asynchronous 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 = ...;
+         * // We can wait until the set operation finishes by waiting on the future
+         * std::future<void> res = object_.setPropertyAsync("state").onInterface("com.kistler.foo").toValue(state).getResultAsFuture();
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] AsyncPropertySetter setPropertyAsync(const std::string& propertyName);
+
+        /*!
+         * @brief Gets values of all properties of the D-Bus object
+         *
+         * @return A helper object for convenient getting of properties' values
+         *
+         * This is a high-level, convenience way of reading D-Bus properties' values that abstracts
+         * from the D-Bus message concept.
+         *
+         * Example of use:
+         * @code
+         * auto props = object.getAllProperties().onInterface("com.kistler.foo");
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] AllPropertiesGetter getAllProperties();
+
+        /*!
+         * @brief Gets values of all properties of the D-Bus object asynchronously
+         *
+         * @return A helper object for convenient asynchronous getting of properties' values
+         *
+         * This is a high-level, convenience way of reading D-Bus properties' values that abstracts
+         * from the D-Bus message concept.
+         *
+         * Example of use:
+         * @code
+         * auto callback = [](std::optional<sdbus::Error> err, const std::map<std::string, Variant>>& properties){ ... };
+         * auto props = object.getAllPropertiesAsync().onInterface("com.kistler.foo").uponReplyInvoke(std::move(callback));
+         * @endcode
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        [[nodiscard]] AsyncAllPropertiesGetter getAllPropertiesAsync();
+
         /*!
          * @brief Provides D-Bus connection used by the proxy
          *
          * @return Reference to the D-Bus connection
          */
-        virtual sdbus::IConnection& getConnection() const = 0;
+        [[nodiscard]] virtual sdbus::IConnection& getConnection() const = 0;
 
         /*!
          * @brief Returns object path of the underlying DBus object
          */
-        virtual const std::string& getObjectPath() const = 0;
+        [[nodiscard]] virtual const std::string& getObjectPath() const = 0;
 
         /*!
-         * @brief Provides currently processed D-Bus message
+         * @brief Provides access to the currently processed D-Bus message
          *
-         * This method provides immutable access to the currently processed incoming D-Bus message.
+         * This method provides access to the currently processed incoming D-Bus message.
          * "Currently processed" means that the registered callback handler(s) for that message
          * are being invoked. This method is meant to be called from within a callback handler
          * (e.g. from a D-Bus signal handler, or async method reply handler, etc.). In such a case it is
-         * guaranteed to return a valid pointer to the D-Bus message for which the handler is called.
-         * If called from other contexts/threads, it may return a nonzero pointer or a nullptr, depending
-         * on whether a message was processed at the time of call or not, but the value is nondereferencable,
-         * since the pointed-to message may have gone in the meantime.
+         * guaranteed to return a valid D-Bus message instance for which the handler is called.
+         * If called from other contexts/threads, it may return a valid or invalid message, depending
+         * on whether a message was processed or not at the time of the call.
          *
-         * @return A pointer to the currently processed D-Bus message
+         * @return Currently processed D-Bus message
          */
-        virtual const Message* getCurrentlyProcessedMessage() const = 0;
+        [[nodiscard]] virtual Message getCurrentlyProcessedMessage() const = 0;
     };
 
     /********************************************//**
@@ -356,7 +488,7 @@ namespace sdbus {
          * 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;
+        [[nodiscard]] bool isPending() const;
 
     private:
         friend internal::Proxy;
@@ -376,10 +508,21 @@ namespace sdbus {
     }
 
     template <typename _Rep, typename _Period>
-    inline PendingAsyncCall IProxy::callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, const std::chrono::duration<_Rep, _Period>& timeout)
+    inline PendingAsyncCall IProxy::callMethodAsync( 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());
+        return callMethodAsync(message, std::move(asyncReplyCallback), microsecs.count());
+    }
+
+    template <typename _Rep, typename _Period>
+    inline std::future<MethodReply> IProxy::callMethodAsync( const MethodCall& message
+                                                           , const std::chrono::duration<_Rep, _Period>& timeout
+                                                           , with_future_t )
+    {
+        auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
+        return callMethodAsync(message, microsecs.count(), with_future);
     }
 
     inline MethodInvoker IProxy::callMethod(const std::string& methodName)
@@ -397,21 +540,36 @@ namespace sdbus {
         return SignalSubscriber(*this, signalName);
     }
 
-    inline SignalUnsubscriber IProxy::muteSignal(const std::string& signalName)
-    {
-        return SignalUnsubscriber(*this, signalName);
-    }
-
     inline PropertyGetter IProxy::getProperty(const std::string& propertyName)
     {
         return PropertyGetter(*this, propertyName);
     }
 
+    inline AsyncPropertyGetter IProxy::getPropertyAsync(const std::string& propertyName)
+    {
+        return AsyncPropertyGetter(*this, propertyName);
+    }
+
     inline PropertySetter IProxy::setProperty(const std::string& propertyName)
     {
         return PropertySetter(*this, propertyName);
     }
 
+    inline AsyncPropertySetter IProxy::setPropertyAsync(const std::string& propertyName)
+    {
+        return AsyncPropertySetter(*this, propertyName);
+    }
+
+    inline AllPropertiesGetter IProxy::getAllProperties()
+    {
+        return AllPropertiesGetter(*this);
+    }
+
+    inline AsyncAllPropertiesGetter IProxy::getAllPropertiesAsync()
+    {
+        return AsyncAllPropertiesGetter(*this);
+    }
+
     /*!
      * @brief Creates a proxy object for a specific remote D-Bus object
      *
@@ -426,6 +584,9 @@ namespace sdbus {
      * 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.
      *
+     * The destination parameter may be an empty string (useful e.g. in case of direct
+     * D-Bus connections to a custom server bus).
+     *
      * Code example:
      * @code
      * auto proxy = sdbus::createProxy(connection, "com.kistler.foo", "/com/kistler/foo");
@@ -449,6 +610,9 @@ namespace sdbus {
      * 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.
      *
+     * The destination parameter may be an empty string (useful e.g. in case of direct
+     * D-Bus connections to a custom server bus).
+     *
      * Code example:
      * @code
      * auto proxy = sdbus::createProxy(std::move(connection), "com.kistler.foo", "/com/kistler/foo");
@@ -458,6 +622,34 @@ namespace sdbus {
                                                             , 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.
+     * The Object proxy becomes an exclusive owner of this connection, but will not start
+     * an event loop thread on this connection. This is cheap construction and is suitable
+     * for short-lived proxies created just to execute simple synchronous D-Bus calls and
+     * then destroyed. Such blocking request-reply calls will work without an event loop
+     * (but signals, async calls, etc. won't).
+     *
+     * The destination parameter may be an empty string (useful e.g. in case of direct
+     * D-Bus connections to a custom server bus).
+     *
+     * Code example:
+     * @code
+     * auto proxy = sdbus::createProxy(std::move(connection), "com.kistler.foo", "/com/kistler/foo", sdbus::dont_run_event_loop_thread);
+     * @endcode
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<sdbus::IConnection>&& connection
+                                                            , std::string destination
+                                                            , std::string objectPath
+                                                            , dont_run_event_loop_thread_t );
+
     /*!
      * @brief Creates a proxy object for a specific remote D-Bus object
      *
@@ -466,7 +658,7 @@ namespace sdbus {
      * @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
+     * his own connection, and will automatically start an event 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.
      *
@@ -478,6 +670,28 @@ namespace sdbus {
     [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( 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, but it will not start an event loop thread. This is cheap
+     * construction and is suitable for short-lived proxies created just to execute simple
+     * synchronous D-Bus calls and then destroyed. Such blocking request-reply calls
+     * will work without an event loop (but signals, async calls, etc. won't).
+     *
+     * Code example:
+     * @code
+     * auto proxy = sdbus::createProxy("com.kistler.foo", "/com/kistler/foo", sdbus::dont_run_event_loop_thread );
+     * @endcode
+     */
+    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
+                                                            , std::string objectPath
+                                                            , dont_run_event_loop_thread_t );
+
 }
 
 #include <sdbus-c++/ConvenienceApiClasses.inl>

include/sdbus-c++/Message.h

@@ -27,16 +27,23 @@
 #ifndef SDBUS_CXX_MESSAGE_H_
 #define SDBUS_CXX_MESSAGE_H_
 
-#include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Error.h>
-#include <string>
-#include <vector>
-#include <map>
-#include <utility>
-#include <cstdint>
+#include <sdbus-c++/TypeTraits.h>
+
+#include <algorithm>
+#include <array>
 #include <cassert>
+#include <cstdint>
 #include <functional>
+#include <map>
+#if __cplusplus >= 202002L
+#include <span>
+#endif
+#include <string>
 #include <sys/types.h>
+#include <unordered_map>
+#include <utility>
+#include <vector>
 
 // Forward declarations
 namespace sdbus {
@@ -48,7 +55,6 @@ namespace sdbus {
     class MethodReply;
     namespace internal {
         class ISdBus;
-        class IConnection;
     }
 }
 
@@ -63,13 +69,19 @@ namespace sdbus {
      * Serialization and deserialization functions are provided for types supported
      * by D-Bus.
      *
-     * You don't need to work with this class directly if you use high-level APIs
-     * of @c IObject and @c IProxy.
+     * You mostly don't need to work with this class directly if you use high-level
+     * APIs of @c IObject and @c IProxy.
      *
      ***********************************************/
     class [[nodiscard]] Message
     {
     public:
+        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);
@@ -86,6 +98,23 @@ namespace sdbus {
         Message& operator<<(const Signature &item);
         Message& operator<<(const UnixFd &item);
 
+        template <typename _Element, typename _Allocator>
+        Message& operator<<(const std::vector<_Element, _Allocator>& items);
+        template <typename _Element, std::size_t _Size>
+        Message& operator<<(const std::array<_Element, _Size>& items);
+#if __cplusplus >= 202002L
+        template <typename _Element, std::size_t _Extent>
+        Message& operator<<(const std::span<_Element, _Extent>& items);
+#endif
+        template <typename _Key, typename _Value, typename _Compare, typename _Allocator>
+        Message& operator<<(const std::map<_Key, _Value, _Compare, _Allocator>& items);
+        template <typename _Key, typename _Value, typename _Hash, typename _KeyEqual, typename _Allocator>
+        Message& operator<<(const std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>& items);
+        template <typename... _ValueTypes>
+        Message& operator<<(const Struct<_ValueTypes...>& item);
+        template <typename... _ValueTypes>
+        Message& operator<<(const std::tuple<_ValueTypes...>& item);
+
         Message& operator>>(bool& item);
         Message& operator>>(int16_t& item);
         Message& operator>>(int32_t& item);
@@ -101,6 +130,22 @@ namespace sdbus {
         Message& operator>>(ObjectPath &item);
         Message& operator>>(Signature &item);
         Message& operator>>(UnixFd &item);
+        template <typename _Element, typename _Allocator>
+        Message& operator>>(std::vector<_Element, _Allocator>& items);
+        template <typename _Element, std::size_t _Size>
+        Message& operator>>(std::array<_Element, _Size>& items);
+#if __cplusplus >= 202002L
+        template <typename _Element, std::size_t _Extent>
+        Message& operator>>(std::span<_Element, _Extent>& items);
+#endif
+        template <typename _Key, typename _Value, typename _Compare, typename _Allocator>
+        Message& operator>>(std::map<_Key, _Value, _Compare, _Allocator>& items);
+        template <typename _Key, typename _Value, typename _Hash, typename _KeyEqual, typename _Allocator>
+        Message& operator>>(std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>& items);
+        template <typename... _ValueTypes>
+        Message& operator>>(Struct<_ValueTypes...>& item);
+        template <typename... _ValueTypes>
+        Message& operator>>(std::tuple<_ValueTypes...>& item);
 
         Message& openContainer(const std::string& signature);
         Message& closeContainer();
@@ -120,6 +165,9 @@ namespace sdbus {
         Message& enterStruct(const std::string& signature);
         Message& exitStruct();
 
+        Message& appendArray(char type, const void *ptr, size_t size);
+        Message& readArray(char type, const void **ptr, size_t *size);
+
         explicit operator bool() const;
         void clearFlags();
 
@@ -131,6 +179,7 @@ namespace sdbus {
         void peekType(std::string& type, std::string& contents) const;
         bool isValid() const;
         bool isEmpty() const;
+        bool isAtEnd(bool complete) const;
 
         void copyTo(Message& destination, bool complete) const;
         void seal();
@@ -146,19 +195,31 @@ namespace sdbus {
 
         class Factory;
 
+    private:
+        template <typename _Array>
+        void serializeArray(const _Array& items);
+        template <typename _Array>
+        void deserializeArray(_Array& items);
+        template <typename _Array>
+        void deserializeArrayFast(_Array& items);
+        template <typename _Element, typename _Allocator>
+        void deserializeArrayFast(std::vector<_Element, _Allocator>& items);
+        template <typename _Array>
+        void deserializeArraySlow(_Array& items);
+        template <typename _Element, typename _Allocator>
+        void deserializeArraySlow(std::vector<_Element, _Allocator>& items);
+
+        template <typename _Dictionary>
+        void serializeDictionary(const _Dictionary& items);
+        template <typename _Dictionary>
+        void deserializeDictionary(_Dictionary& items);
+
     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:
@@ -176,7 +237,6 @@ namespace sdbus {
         MethodCall() = default;
 
         MethodReply send(uint64_t timeout) const;
-        [[deprecated("Use send overload with floating_slot instead")]] void send(void* callback, void* userData, uint64_t timeout, dont_request_slot_t) const;
         void send(void* callback, void* userData, uint64_t timeout, floating_slot_t) const;
         [[nodiscard]] Slot send(void* callback, void* userData, uint64_t timeout) const;
 
@@ -187,12 +247,11 @@ namespace sdbus {
         bool doesntExpectReply() const;
 
     protected:
-        MethodCall(void *msg, internal::ISdBus* sdbus, const internal::IConnection* connection, adopt_message_t) noexcept;
+        MethodCall(void *msg, internal::ISdBus* sdbus, adopt_message_t) noexcept;
 
     private:
         MethodReply sendWithReply(uint64_t timeout = 0) const;
         MethodReply sendWithNoReply() const;
-        const internal::IConnection* connection_{};
     };
 
     class MethodReply : public Message
@@ -244,38 +303,90 @@ namespace sdbus {
         PlainMessage() = default;
     };
 
-    template <typename _Element>
-    inline Message& operator<<(Message& msg, const std::vector<_Element>& items)
+    template <typename _Element, typename _Allocator>
+    inline Message& Message::operator<<(const std::vector<_Element, _Allocator>& items)
     {
-        msg.openContainer(signature_of<_Element>::str());
+        serializeArray(items);
 
-        for (const auto& item : items)
-            msg << item;
-
-        msg.closeContainer();
-
-        return msg;
+        return *this;
     }
 
-    template <typename _Key, typename _Value>
-    inline Message& operator<<(Message& msg, const std::map<_Key, _Value>& items)
+    template <typename _Element, std::size_t _Size>
+    inline Message& Message::operator<<(const std::array<_Element, _Size>& items)
     {
-        const std::string dictEntrySignature = signature_of<_Key>::str() + signature_of<_Value>::str();
+        serializeArray(items);
+
+        return *this;
+    }
+
+#if __cplusplus >= 202002L
+    template <typename _Element, std::size_t _Extent>
+    inline Message& Message::operator<<(const std::span<_Element, _Extent>& items)
+    {
+        serializeArray(items);
+
+        return *this;
+    }
+#endif
+
+    template <typename _Array>
+    inline void Message::serializeArray(const _Array& items)
+    {
+        using ElementType = typename _Array::value_type;
+
+        // Use faster, one-step serialization of contiguous array of elements of trivial D-Bus types except bool,
+        // otherwise use step-by-step serialization of individual elements.
+        if constexpr (signature_of<ElementType>::is_trivial_dbus_type && !std::is_same_v<ElementType, bool>)
+        {
+            appendArray(*signature_of<ElementType>::str().c_str(), items.data(), items.size() * sizeof(ElementType));
+        }
+        else
+        {
+            openContainer(signature_of<ElementType>::str());
+
+            for (const auto& item : items)
+                *this << item;
+
+            closeContainer();
+        }
+    }
+
+    template <typename _Key, typename _Value, typename _Compare, typename _Allocator>
+    inline Message& Message::operator<<(const std::map<_Key, _Value, _Compare, _Allocator>& items)
+    {
+        serializeDictionary(items);
+
+        return *this;
+    }
+
+    template <typename _Key, typename _Value, typename _Hash, typename _KeyEqual, typename _Allocator>
+    inline Message& Message::operator<<(const std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>& items)
+    {
+        serializeDictionary(items);
+
+        return *this;
+    }
+
+    template <typename _Dictionary>
+    inline void Message::serializeDictionary(const _Dictionary& items)
+    {
+        using KeyType = typename _Dictionary::key_type;
+        using ValueType = typename _Dictionary::mapped_type;
+
+        const std::string dictEntrySignature = signature_of<KeyType>::str() + signature_of<ValueType>::str();
         const std::string arraySignature = "{" + dictEntrySignature + "}";
 
-        msg.openContainer(arraySignature);
+        openContainer(arraySignature);
 
         for (const auto& item : items)
         {
-            msg.openDictEntry(dictEntrySignature);
-            msg << item.first;
-            msg << item.second;
-            msg.closeDictEntry();
+            openDictEntry(dictEntrySignature);
+            *this << item.first;
+            *this << item.second;
+            closeDictEntry();
         }
 
-        msg.closeContainer();
-
-        return msg;
+        closeContainer();
     }
 
     namespace detail
@@ -296,78 +407,182 @@ namespace sdbus {
     }
 
     template <typename... _ValueTypes>
-    inline Message& operator<<(Message& msg, const Struct<_ValueTypes...>& item)
+    inline Message& Message::operator<<(const Struct<_ValueTypes...>& item)
     {
         auto structSignature = signature_of<Struct<_ValueTypes...>>::str();
         assert(structSignature.size() > 2);
         // Remove opening and closing parenthesis from the struct signature to get contents signature
-        auto structContentSignature = structSignature.substr(1, structSignature.size()-2);
+        auto structContentSignature = structSignature.substr(1, structSignature.size() - 2);
 
-        msg.openStruct(structContentSignature);
-        detail::serialize_tuple(msg, item, std::index_sequence_for<_ValueTypes...>{});
-        msg.closeStruct();
+        openStruct(structContentSignature);
+        detail::serialize_tuple(*this, item, std::index_sequence_for<_ValueTypes...>{});
+        closeStruct();
 
-        return msg;
+        return *this;
     }
 
     template <typename... _ValueTypes>
-    inline Message& operator<<(Message& msg, const std::tuple<_ValueTypes...>& item)
+    inline Message& Message::operator<<(const std::tuple<_ValueTypes...>& item)
     {
-        detail::serialize_tuple(msg, item, std::index_sequence_for<_ValueTypes...>{});
-        return msg;
+        detail::serialize_tuple(*this, item, std::index_sequence_for<_ValueTypes...>{});
+        return *this;
     }
 
-
-    template <typename _Element>
-    inline Message& operator>>(Message& msg, std::vector<_Element>& items)
+    template <typename _Element, typename _Allocator>
+    inline Message& Message::operator>>(std::vector<_Element, _Allocator>& items)
     {
-        if(!msg.enterContainer(signature_of<_Element>::str()))
-            return msg;
+        deserializeArray(items);
+
+        return *this;
+    }
+
+    template <typename _Element, std::size_t _Size>
+    inline Message& Message::operator>>(std::array<_Element, _Size>& items)
+    {
+        deserializeArray(items);
+
+        return *this;
+    }
+
+#if __cplusplus >= 202002L
+    template <typename _Element, std::size_t _Extent>
+    inline Message& Message::operator>>(std::span<_Element, _Extent>& items)
+    {
+        deserializeArray(items);
+
+        return *this;
+    }
+#endif
+
+    template <typename _Array>
+    inline void Message::deserializeArray(_Array& items)
+    {
+        using ElementType = typename _Array::value_type;
+
+        // Use faster, one-step deserialization of contiguous array of elements of trivial D-Bus types except bool,
+        // otherwise use step-by-step deserialization of individual elements.
+        if constexpr (signature_of<ElementType>::is_trivial_dbus_type && !std::is_same_v<ElementType, bool>)
+        {
+            deserializeArrayFast(items);
+        }
+        else
+        {
+            deserializeArraySlow(items);
+        }
+    }
+
+    template <typename _Array>
+    inline void Message::deserializeArrayFast(_Array& items)
+    {
+        using ElementType = typename _Array::value_type;
+
+        size_t arraySize{};
+        const ElementType* arrayPtr{};
+
+        readArray(*signature_of<ElementType>::str().c_str(), (const void**)&arrayPtr, &arraySize);
+
+        size_t elementsInMsg = arraySize / sizeof(ElementType);
+        bool notEnoughSpace = items.size() < elementsInMsg;
+        SDBUS_THROW_ERROR_IF(notEnoughSpace, "Failed to deserialize array: not enough space in destination sequence", EINVAL);
+
+        std::copy_n(arrayPtr, elementsInMsg, items.begin());
+    }
+
+    template <typename _Element, typename _Allocator>
+    void Message::deserializeArrayFast(std::vector<_Element, _Allocator>& items)
+    {
+        size_t arraySize{};
+        const _Element* arrayPtr{};
+
+        readArray(*signature_of<_Element>::str().c_str(), (const void**)&arrayPtr, &arraySize);
+
+        items.insert(items.end(), arrayPtr, arrayPtr + (arraySize / sizeof(_Element)));
+    }
+
+    template <typename _Array>
+    inline void Message::deserializeArraySlow(_Array& items)
+    {
+        using ElementType = typename _Array::value_type;
+
+        if(!enterContainer(signature_of<ElementType>::str()))
+            return;
+
+        for (auto& elem : items)
+            if (!(*this >> elem))
+                break; // Keep the rest in the destination sequence untouched
+
+        SDBUS_THROW_ERROR_IF(!isAtEnd(false), "Failed to deserialize array: not enough space in destination sequence", EINVAL);
+
+        clearFlags();
+
+        exitContainer();
+    }
+
+    template <typename _Element, typename _Allocator>
+    void Message::deserializeArraySlow(std::vector<_Element, _Allocator>& items)
+    {
+        if(!enterContainer(signature_of<_Element>::str()))
+            return;
 
         while (true)
         {
             _Element elem;
-            if (msg >> elem)
+            if (*this >> elem)
                 items.emplace_back(std::move(elem));
             else
                 break;
         }
 
-        msg.clearFlags();
+        clearFlags();
 
-        msg.exitContainer();
-
-        return msg;
+        exitContainer();
     }
 
-    template <typename _Key, typename _Value>
-    inline Message& operator>>(Message& msg, std::map<_Key, _Value>& items)
+    template <typename _Key, typename _Value, typename _Compare, typename _Allocator>
+    inline Message& Message::operator>>(std::map<_Key, _Value, _Compare, _Allocator>& items)
     {
-        const std::string dictEntrySignature = signature_of<_Key>::str() + signature_of<_Value>::str();
+        deserializeDictionary(items);
+
+        return *this;
+    }
+
+    template <typename _Key, typename _Value, typename _Hash, typename _KeyEqual, typename _Allocator>
+    inline Message& Message::operator>>(std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>& items)
+    {
+        deserializeDictionary(items);
+
+        return *this;
+    }
+
+    template <typename _Dictionary>
+    inline void Message::deserializeDictionary(_Dictionary& items)
+    {
+        using KeyType = typename _Dictionary::key_type;
+        using ValueType = typename _Dictionary::mapped_type;
+
+        const std::string dictEntrySignature = signature_of<KeyType>::str() + signature_of<ValueType>::str();
         const std::string arraySignature = "{" + dictEntrySignature + "}";
 
-        if (!msg.enterContainer(arraySignature))
-            return msg;
+        if (!enterContainer(arraySignature))
+            return;
 
         while (true)
         {
-            if (!msg.enterDictEntry(dictEntrySignature))
+            if (!enterDictEntry(dictEntrySignature))
                 break;
 
-            _Key key;
-            _Value value;
-            msg >> key >> value;
+            KeyType key;
+            ValueType value;
+            *this >> key >> value;
 
             items.emplace(std::move(key), std::move(value));
 
-            msg.exitDictEntry();
+            exitDictEntry();
         }
 
-        msg.clearFlags();
+        clearFlags();
 
-        msg.exitContainer();
-
-        return msg;
+        exitContainer();
     }
 
     namespace detail
@@ -388,27 +603,27 @@ namespace sdbus {
     }
 
     template <typename... _ValueTypes>
-    inline Message& operator>>(Message& msg, Struct<_ValueTypes...>& item)
+    inline Message& Message::operator>>(Struct<_ValueTypes...>& item)
     {
         auto structSignature = signature_of<Struct<_ValueTypes...>>::str();
         // Remove opening and closing parenthesis from the struct signature to get contents signature
         auto structContentSignature = structSignature.substr(1, structSignature.size()-2);
 
-        if (!msg.enterStruct(structContentSignature))
-            return msg;
+        if (!enterStruct(structContentSignature))
+            return *this;
 
-        detail::deserialize_tuple(msg, item, std::index_sequence_for<_ValueTypes...>{});
+        detail::deserialize_tuple(*this, item, std::index_sequence_for<_ValueTypes...>{});
 
-        msg.exitStruct();
+        exitStruct();
 
-        return msg;
+        return *this;
     }
 
     template <typename... _ValueTypes>
-    inline Message& operator>>(Message& msg, std::tuple<_ValueTypes...>& item)
+    inline Message& Message::operator>>(std::tuple<_ValueTypes...>& item)
     {
-        detail::deserialize_tuple(msg, item, std::index_sequence_for<_ValueTypes...>{});
-        return msg;
+        detail::deserialize_tuple(*this, item, std::index_sequence_for<_ValueTypes...>{});
+        return *this;
     }
 
 }

include/sdbus-c++/MethodResult.h

@@ -28,9 +28,10 @@
 #define SDBUS_CXX_METHODRESULT_H_
 
 #include <sdbus-c++/Message.h>
+
 #include <cassert>
 
-// Forward declaration
+// Forward declarations
 namespace sdbus {
     class Error;
 }
@@ -76,7 +77,7 @@ namespace sdbus {
     {
         assert(call_.isValid());
         auto reply = call_.createReply();
-        (reply << ... << results);
+        (void)(reply << ... << results);
         reply.send();
     }
 

include/sdbus-c++/ProxyInterfaces.h

@@ -83,9 +83,10 @@ namespace sdbus {
      * 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();`).
+     * In the final adaptor class inherited from ProxyInterfaces, one needs to make sure:
+     *   1. to call `registerProxy();` in the class constructor, and, conversely,
+     *   2. to call `unregisterProxy();` in the class destructor,
+     * so that the signals are subscribed to and unsubscribed from at a proper time.
      *
      ***********************************************/
     template <typename... _Interfaces>
@@ -109,6 +110,21 @@ namespace sdbus {
         {
         }
 
+        /*!
+         * @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,sdbus::dont_run_event_loop_thread_t)
+         */
+        ProxyInterfaces(std::string destination, std::string objectPath, dont_run_event_loop_thread_t)
+            : ProxyObjectHolder(createProxy(std::move(destination), std::move(objectPath), dont_run_event_loop_thread))
+            , _Interfaces(getProxy())...
+        {
+        }
+
         /*!
          * @brief Creates native-like proxy object instance
          *
@@ -142,15 +158,31 @@ namespace sdbus {
         }
 
         /*!
-         * @brief Finishes proxy registration and makes the proxy ready for use
+         * @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,sdbus::dont_run_event_loop_thread_t)
+         */
+        ProxyInterfaces(std::unique_ptr<sdbus::IConnection>&& connection, std::string destination, std::string objectPath, dont_run_event_loop_thread_t)
+                : ProxyObjectHolder(createProxy(std::move(connection), std::move(destination), std::move(objectPath), dont_run_event_loop_thread))
+                , _Interfaces(getProxy())...
+        {
+        }
+
+        /*!
+         * @brief Registers handlers for D-Bus signals of the remote object
          *
          * This function must be called in the constructor of the final proxy class that implements ProxyInterfaces.
          *
-         * For more information, see underlying @ref IProxy::finishRegistration()
+         * See also @ref IProxy::registerSignalHandler()
          */
         void registerProxy()
         {
-            getProxy().finishRegistration();
+            (_Interfaces::registerProxy(), ...);
         }
 
         /*!
@@ -166,15 +198,17 @@ namespace sdbus {
         }
 
         /*!
-         * @brief Returns object path of the underlying DBus object
+         * @brief Returns reference to the underlying IProxy instance
          */
-        const std::string& getObjectPath() const
-        {
-            return getProxy().getObjectPath();
-        }
+        using ProxyObjectHolder::getProxy;
 
     protected:
         using base_type = ProxyInterfaces;
+
+        ProxyInterfaces(const ProxyInterfaces&) = delete;
+        ProxyInterfaces& operator=(const ProxyInterfaces&) = delete;
+        ProxyInterfaces(ProxyInterfaces&&) = default;
+        ProxyInterfaces& operator=(ProxyInterfaces&&) = default;
         ~ProxyInterfaces() = default;
     };
 

include/sdbus-c++/StandardInterfaces.h

@@ -43,27 +43,36 @@ namespace sdbus {
 
     protected:
         Peer_proxy(sdbus::IProxy& proxy)
-            : proxy_(proxy)
+            : proxy_(&proxy)
         {
         }
 
+        Peer_proxy(const Peer_proxy&) = delete;
+        Peer_proxy& operator=(const Peer_proxy&) = delete;
+        Peer_proxy(Peer_proxy&&) = default;
+        Peer_proxy& operator=(Peer_proxy&&) = default;
+
         ~Peer_proxy() = default;
 
+        void registerProxy()
+        {
+        }
+
     public:
         void Ping()
         {
-            proxy_.callMethod("Ping").onInterface(INTERFACE_NAME);
+            proxy_->callMethod("Ping").onInterface(INTERFACE_NAME);
         }
 
         std::string GetMachineId()
         {
             std::string machineUUID;
-            proxy_.callMethod("GetMachineId").onInterface(INTERFACE_NAME).storeResultsTo(machineUUID);
+            proxy_->callMethod("GetMachineId").onInterface(INTERFACE_NAME).storeResultsTo(machineUUID);
             return machineUUID;
         }
 
     private:
-        sdbus::IProxy& proxy_;
+        sdbus::IProxy* proxy_;
     };
 
     // Proxy for introspection
@@ -73,22 +82,31 @@ namespace sdbus {
 
     protected:
         Introspectable_proxy(sdbus::IProxy& proxy)
-            : proxy_(proxy)
+            : proxy_(&proxy)
         {
         }
 
+        Introspectable_proxy(const Introspectable_proxy&) = delete;
+        Introspectable_proxy& operator=(const Introspectable_proxy&) = delete;
+        Introspectable_proxy(Introspectable_proxy&&) = default;
+        Introspectable_proxy& operator=(Introspectable_proxy&&) = default;
+
         ~Introspectable_proxy() = default;
 
+        void registerProxy()
+        {
+        }
+
     public:
         std::string Introspect()
         {
             std::string xml;
-            proxy_.callMethod("Introspect").onInterface(INTERFACE_NAME).storeResultsTo(xml);
+            proxy_->callMethod("Introspect").onInterface(INTERFACE_NAME).storeResultsTo(xml);
             return xml;
         }
 
     private:
-        sdbus::IProxy& proxy_;
+        sdbus::IProxy* proxy_;
     };
 
     // Proxy for properties
@@ -98,10 +116,21 @@ namespace sdbus {
 
     protected:
         Properties_proxy(sdbus::IProxy& proxy)
-            : proxy_(proxy)
+            : proxy_(&proxy)
+        {
+        }
+
+        Properties_proxy(const Properties_proxy&) = delete;
+        Properties_proxy& operator=(const Properties_proxy&) = delete;
+        Properties_proxy(Properties_proxy&&) = default;
+        Properties_proxy& operator=(Properties_proxy&&) = default;
+
+        ~Properties_proxy() = default;
+
+        void registerProxy()
         {
             proxy_
-                .uponSignal("PropertiesChanged")
+                ->uponSignal("PropertiesChanged")
                 .onInterface(INTERFACE_NAME)
                 .call([this]( const std::string& interfaceName
                             , const std::map<std::string, sdbus::Variant>& changedProperties
@@ -111,8 +140,6 @@ namespace sdbus {
                             });
         }
 
-        ~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;
@@ -120,23 +147,59 @@ namespace sdbus {
     public:
         sdbus::Variant Get(const std::string& interfaceName, const std::string& propertyName)
         {
-            return proxy_.getProperty(propertyName).onInterface(interfaceName);
+            return proxy_->getProperty(propertyName).onInterface(interfaceName);
+        }
+
+        template <typename _Function>
+        PendingAsyncCall GetAsync(const std::string& interfaceName, const std::string& propertyName, _Function&& callback)
+        {
+            return proxy_->getPropertyAsync(propertyName).onInterface(interfaceName).uponReplyInvoke(std::forward<_Function>(callback));
+        }
+
+        std::future<sdbus::Variant> GetAsync(const std::string& interfaceName, const std::string& propertyName, with_future_t)
+        {
+            return proxy_->getPropertyAsync(propertyName).onInterface(interfaceName).getResultAsFuture();
         }
 
         void Set(const std::string& interfaceName, const std::string& propertyName, const sdbus::Variant& value)
         {
-            proxy_.setProperty(propertyName).onInterface(interfaceName).toValue(value);
+            proxy_->setProperty(propertyName).onInterface(interfaceName).toValue(value);
+        }
+
+        void Set(const std::string& interfaceName, const std::string& propertyName, const sdbus::Variant& value, dont_expect_reply_t)
+        {
+            proxy_->setProperty(propertyName).onInterface(interfaceName).toValue(value, dont_expect_reply);
+        }
+
+        template <typename _Function>
+        PendingAsyncCall SetAsync(const std::string& interfaceName, const std::string& propertyName, const sdbus::Variant& value, _Function&& callback)
+        {
+            return proxy_->setPropertyAsync(propertyName).onInterface(interfaceName).toValue(value).uponReplyInvoke(std::forward<_Function>(callback));
+        }
+
+        std::future<void> SetAsync(const std::string& interfaceName, const std::string& propertyName, const sdbus::Variant& value, with_future_t)
+        {
+            return proxy_->setPropertyAsync(propertyName).onInterface(interfaceName).toValue(value).getResultAsFuture();
         }
 
         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;
+            return proxy_->getAllProperties().onInterface(interfaceName);
+        }
+
+        template <typename _Function>
+        PendingAsyncCall GetAllAsync(const std::string& interfaceName, _Function&& callback)
+        {
+            return proxy_->getAllPropertiesAsync().onInterface(interfaceName).uponReplyInvoke(std::forward<_Function>(callback));
+        }
+
+        std::future<std::map<std::string, sdbus::Variant>> GetAllAsync(const std::string& interfaceName, with_future_t)
+        {
+            return proxy_->getAllPropertiesAsync().onInterface(interfaceName).getResultAsFuture();
         }
 
     private:
-        sdbus::IProxy& proxy_;
+        sdbus::IProxy* proxy_;
     };
 
     // Proxy for object manager
@@ -146,10 +209,21 @@ namespace sdbus {
 
     protected:
         ObjectManager_proxy(sdbus::IProxy& proxy)
-            : proxy_(proxy)
+            : proxy_(&proxy)
+        {
+        }
+
+        ObjectManager_proxy(const ObjectManager_proxy&) = delete;
+        ObjectManager_proxy& operator=(const ObjectManager_proxy&) = delete;
+        ObjectManager_proxy(ObjectManager_proxy&&) = default;
+        ObjectManager_proxy& operator=(ObjectManager_proxy&&) = default;
+
+        ~ObjectManager_proxy() = default;
+
+        void registerProxy()
         {
             proxy_
-                .uponSignal("InterfacesAdded")
+                ->uponSignal("InterfacesAdded")
                 .onInterface(INTERFACE_NAME)
                 .call([this]( const sdbus::ObjectPath& objectPath
                             , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
@@ -157,8 +231,7 @@ namespace sdbus {
                                 this->onInterfacesAdded(objectPath, interfacesAndProperties);
                             });
 
-            proxy_
-                .uponSignal("InterfacesRemoved")
+            proxy_->uponSignal("InterfacesRemoved")
                 .onInterface(INTERFACE_NAME)
                 .call([this]( const sdbus::ObjectPath& objectPath
                             , const std::vector<std::string>& interfaces )
@@ -167,8 +240,6 @@ namespace sdbus {
                             });
         }
 
-        ~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
@@ -178,12 +249,12 @@ namespace sdbus {
         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);
+            proxy_->callMethod("GetManagedObjects").onInterface(INTERFACE_NAME).storeResultsTo(objectsInterfacesAndProperties);
             return objectsInterfacesAndProperties;
         }
 
     private:
-        sdbus::IProxy& proxy_;
+        sdbus::IProxy* proxy_;
     };
 
     // Adaptors for the above-listed standard D-Bus interfaces are not necessary because the functionality
@@ -196,26 +267,34 @@ namespace sdbus {
         static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.Properties";
 
     protected:
-        Properties_adaptor(sdbus::IObject& object)
-            : object_(object)
+        Properties_adaptor(sdbus::IObject& object) : object_(&object)
         {
         }
 
+        Properties_adaptor(const Properties_adaptor&) = delete;
+        Properties_adaptor& operator=(const Properties_adaptor&) = delete;
+        Properties_adaptor(Properties_adaptor&&) = default;
+        Properties_adaptor& operator=(Properties_adaptor&&) = default;
+
         ~Properties_adaptor() = default;
 
+        void registerAdaptor()
+        {
+        }
+
     public:
         void emitPropertiesChangedSignal(const std::string& interfaceName, const std::vector<std::string>& properties)
         {
-            object_.emitPropertiesChangedSignal(interfaceName, properties);
+            object_->emitPropertiesChangedSignal(interfaceName, properties);
         }
 
         void emitPropertiesChangedSignal(const std::string& interfaceName)
         {
-            object_.emitPropertiesChangedSignal(interfaceName);
+            object_->emitPropertiesChangedSignal(interfaceName);
         }
 
     private:
-        sdbus::IObject& object_;
+        sdbus::IObject* object_;
     };
 
     /*!
@@ -233,16 +312,24 @@ namespace sdbus {
         static constexpr const char* INTERFACE_NAME = "org.freedesktop.DBus.ObjectManager";
 
     protected:
-        explicit ObjectManager_adaptor(sdbus::IObject& object)
-            : object_(object)
+        explicit ObjectManager_adaptor(sdbus::IObject& object) : object_(&object)
         {
-            object_.addObjectManager();
         }
 
+        ObjectManager_adaptor(const ObjectManager_adaptor&) = delete;
+        ObjectManager_adaptor& operator=(const ObjectManager_adaptor&) = delete;
+        ObjectManager_adaptor(ObjectManager_adaptor&&) = default;
+        ObjectManager_adaptor& operator=(ObjectManager_adaptor&&) = default;
+
         ~ObjectManager_adaptor() = default;
 
+        void registerAdaptor()
+        {
+            object_->addObjectManager();
+        }
+
     private:
-        sdbus::IObject& object_;
+        sdbus::IObject* object_;
     };
 
     /*!
@@ -259,12 +346,22 @@ namespace sdbus {
     class ManagedObject_adaptor
     {
     protected:
-        explicit ManagedObject_adaptor(sdbus::IObject& object) : object_(object)
+        explicit ManagedObject_adaptor(sdbus::IObject& object)
+            : object_(&object)
         {
         }
 
+        ManagedObject_adaptor(const ManagedObject_adaptor&) = delete;
+        ManagedObject_adaptor& operator=(const ManagedObject_adaptor&) = delete;
+        ManagedObject_adaptor(ManagedObject_adaptor&&) = default;
+        ManagedObject_adaptor& operator=(ManagedObject_adaptor&&) = default;
+
         ~ManagedObject_adaptor() = default;
 
+        void registerAdaptor()
+        {
+        }
+
     public:
         /*!
          * @brief Emits InterfacesAdded signal for this object path
@@ -273,7 +370,7 @@ namespace sdbus {
          */
         void emitInterfacesAddedSignal()
         {
-            object_.emitInterfacesAddedSignal();
+            object_->emitInterfacesAddedSignal();
         }
 
         /*!
@@ -283,7 +380,7 @@ namespace sdbus {
          */
         void emitInterfacesAddedSignal(const std::vector<std::string>& interfaces)
         {
-            object_.emitInterfacesAddedSignal(interfaces);
+            object_->emitInterfacesAddedSignal(interfaces);
         }
 
         /*!
@@ -293,7 +390,7 @@ namespace sdbus {
          */
         void emitInterfacesRemovedSignal()
         {
-            object_.emitInterfacesRemovedSignal();
+            object_->emitInterfacesRemovedSignal();
         }
 
         /*!
@@ -303,11 +400,11 @@ namespace sdbus {
          */
         void emitInterfacesRemovedSignal(const std::vector<std::string>& interfaces)
         {
-            object_.emitInterfacesRemovedSignal(interfaces);
+            object_->emitInterfacesRemovedSignal(interfaces);
         }
 
     private:
-        sdbus::IObject& object_;
+        sdbus::IObject* object_;
     };
 
 }

include/sdbus-c++/TypeTraits.h

@@ -27,14 +27,23 @@
 #ifndef SDBUS_CXX_TYPETRAITS_H_
 #define SDBUS_CXX_TYPETRAITS_H_
 
-#include <type_traits>
-#include <string>
-#include <vector>
-#include <map>
+#include <sdbus-c++/Error.h>
+
+#include <array>
 #include <cstdint>
 #include <functional>
+#include <map>
 #include <memory>
+#include <optional>
+#if __cplusplus >= 202002L
+#include <span>
+#endif
+#include <string>
 #include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <variant>
+#include <vector>
 
 // Forward declarations
 namespace sdbus {
@@ -57,36 +66,44 @@ namespace sdbus {
 
     // Callbacks from sdbus-c++
     using method_callback = std::function<void(MethodCall msg)>;
-    using async_reply_handler = std::function<void(MethodReply& reply, const Error* error)>;
-    using signal_handler = std::function<void(Signal& signal)>;
-    using message_handler = std::function<void(Message& msg)>;
-    using property_set_callback = std::function<void(PropertySetCall& msg)>;
+    using async_reply_handler = std::function<void(MethodReply reply, std::optional<Error> error)>;
+    using signal_handler = std::function<void(Signal signal)>;
+    using message_handler = std::function<void(Message msg)>;
+    using property_set_callback = std::function<void(PropertySetCall msg)>;
     using property_get_callback = std::function<void(PropertyGetReply& reply)>;
 
     // Type-erased RAII-style handle to callbacks/subscriptions registered to sdbus-c++
     using Slot = std::unique_ptr<void, std::function<void(void*)>>;
 
-    // Tag specifying that an owning slot handle shall be returned from the function
-    struct request_slot_t { explicit request_slot_t() = default; };
-    inline constexpr request_slot_t request_slot{};
+    // Tag specifying that an owning slot handle shall be returned from a registration/subscription function to the caller
+    struct return_slot_t { explicit return_slot_t() = default; };
+    inline constexpr return_slot_t return_slot{};
     // Tag specifying that the library shall own the slot resulting from the call of the function (so-called floating slot)
     struct floating_slot_t { explicit floating_slot_t() = default; };
     inline constexpr floating_slot_t floating_slot{};
-    // Deprecated name for the above -- a floating slot
-    struct dont_request_slot_t { explicit dont_request_slot_t() = default; };
-    [[deprecated("Replaced by floating_slot")]] inline constexpr dont_request_slot_t dont_request_slot{};
     // Tag denoting the assumption that the caller has already obtained message ownership
     struct adopt_message_t { explicit adopt_message_t() = default; };
     inline constexpr adopt_message_t adopt_message{};
     // Tag denoting the assumption that the caller has already obtained fd ownership
     struct adopt_fd_t { explicit adopt_fd_t() = default; };
     inline constexpr adopt_fd_t adopt_fd{};
+    // Tag specifying that the proxy shall not run an event loop thread on its D-Bus connection.
+    // Such proxies are typically created to carry out a simple synchronous D-Bus call(s) and then are destroyed.
+    struct dont_run_event_loop_thread_t { explicit dont_run_event_loop_thread_t() = default; };
+    inline constexpr dont_run_event_loop_thread_t dont_run_event_loop_thread{};
+    // Tag denoting an asynchronous call that returns std::future as a handle
+    struct with_future_t { explicit with_future_t() = default; };
+    inline constexpr with_future_t with_future{};
+    // Tag denoting a call where the reply shouldn't be waited for
+    struct dont_expect_reply_t { explicit dont_expect_reply_t() = default; };
+    inline constexpr dont_expect_reply_t dont_expect_reply{};
 
     // Template specializations for getting D-Bus signatures from C++ types
     template <typename _T>
     struct signature_of
     {
         static constexpr bool is_valid = false;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -97,10 +114,21 @@ namespace sdbus {
         }
     };
 
+    template <typename _T>
+    struct signature_of<const _T>
+        : public signature_of<_T>
+    {};
+
+    template <typename _T>
+    struct signature_of<_T&>
+            : public signature_of<_T>
+    {};
+
     template <>
     struct signature_of<void>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -112,6 +140,7 @@ namespace sdbus {
     struct signature_of<bool>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -123,6 +152,7 @@ namespace sdbus {
     struct signature_of<uint8_t>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -134,6 +164,7 @@ namespace sdbus {
     struct signature_of<int16_t>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -145,6 +176,7 @@ namespace sdbus {
     struct signature_of<uint16_t>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -156,6 +188,7 @@ namespace sdbus {
     struct signature_of<int32_t>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -167,6 +200,7 @@ namespace sdbus {
     struct signature_of<uint32_t>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -178,6 +212,7 @@ namespace sdbus {
     struct signature_of<int64_t>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -189,6 +224,7 @@ namespace sdbus {
     struct signature_of<uint64_t>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -200,6 +236,7 @@ namespace sdbus {
     struct signature_of<double>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = true;
 
         static const std::string str()
         {
@@ -211,6 +248,7 @@ namespace sdbus {
     struct signature_of<char*>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -222,6 +260,7 @@ namespace sdbus {
     struct signature_of<const char*>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -233,6 +272,7 @@ namespace sdbus {
     struct signature_of<char[_N]>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -244,6 +284,7 @@ namespace sdbus {
     struct signature_of<const char[_N]>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -255,6 +296,7 @@ namespace sdbus {
     struct signature_of<std::string>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -266,6 +308,7 @@ namespace sdbus {
     struct signature_of<Struct<_ValueTypes...>>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -281,6 +324,7 @@ namespace sdbus {
     struct signature_of<Variant>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -292,6 +336,7 @@ namespace sdbus {
     struct signature_of<ObjectPath>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -303,6 +348,7 @@ namespace sdbus {
     struct signature_of<Signature>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -314,6 +360,7 @@ namespace sdbus {
     struct signature_of<UnixFd>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -321,10 +368,11 @@ namespace sdbus {
         }
     };
 
-    template <typename _Element>
-    struct signature_of<std::vector<_Element>>
+    template <typename _Element, typename _Allocator>
+    struct signature_of<std::vector<_Element, _Allocator>>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -332,10 +380,49 @@ namespace sdbus {
         }
     };
 
-    template <typename _Key, typename _Value>
-    struct signature_of<std::map<_Key, _Value>>
+    template <typename _Element, std::size_t _Size>
+    struct signature_of<std::array<_Element, _Size>>
     {
         static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
+
+        static const std::string str()
+        {
+            return "a" + signature_of<_Element>::str();
+        }
+    };
+
+#if __cplusplus >= 202002L
+    template <typename _Element, std::size_t _Extent>
+    struct signature_of<std::span<_Element, _Extent>>
+    {
+        static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
+
+        static const std::string str()
+        {
+            return "a" + signature_of<_Element>::str();
+        }
+    };
+#endif
+
+    template <typename _Key, typename _Value, typename _Compare, typename _Allocator>
+    struct signature_of<std::map<_Key, _Value, _Compare, _Allocator>>
+    {
+        static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
+
+        static const std::string str()
+        {
+            return "a{" + signature_of<_Key>::str() + signature_of<_Value>::str() + "}";
+        }
+    };
+
+    template <typename _Key, typename _Value, typename _Hash, typename _KeyEqual, typename _Allocator>
+    struct signature_of<std::unordered_map<_Key, _Value, _Hash, _KeyEqual, _Allocator>>
+    {
+        static constexpr bool is_valid = true;
+        static constexpr bool is_trivial_dbus_type = false;
 
         static const std::string str()
         {
@@ -406,7 +493,7 @@ namespace sdbus {
     };
 
     template <typename... _Args>
-    struct function_traits<void(const Error*, _Args...)>
+    struct function_traits<void(std::optional<Error>, _Args...)>
         : public function_traits_base<void, _Args...>
     {
         static constexpr bool has_error_param = true;
@@ -540,6 +627,35 @@ namespace sdbus {
         }
     };
 
+
+    template <typename... _Args> struct future_return
+    {
+        typedef std::tuple<_Args...> type;
+    };
+
+    template <> struct future_return<>
+    {
+        typedef void type;
+    };
+
+    template <typename _Type> struct future_return<_Type>
+    {
+        typedef _Type type;
+    };
+
+    template <typename... _Args>
+    using future_return_t = typename future_return<_Args...>::type;
+
+
+    // Credit: Piotr Skotnicki (https://stackoverflow.com/a/57639506)
+    template <typename, typename>
+    constexpr bool is_one_of_variants_types = false;
+
+    template <typename... _VariantTypes, typename _QueriedType>
+    constexpr bool is_one_of_variants_types<std::variant<_VariantTypes...>, _QueriedType>
+        = (std::is_same_v<_QueriedType, _VariantTypes> || ...);
+
+
     namespace detail
     {
         template <class _Function, class _Tuple, typename... _Args, std::size_t... _I>
@@ -552,12 +668,12 @@ namespace sdbus {
         }
 
         template <class _Function, class _Tuple, std::size_t... _I>
-        constexpr decltype(auto) apply_impl( _Function&& f
-                                           , const Error* e
-                                           , _Tuple&& t
-                                           , std::index_sequence<_I...> )
+        decltype(auto) apply_impl( _Function&& f
+                                 , std::optional<Error> e
+                                 , _Tuple&& t
+                                 , std::index_sequence<_I...> )
         {
-            return std::forward<_Function>(f)(e, std::get<_I>(std::forward<_Tuple>(t))...);
+            return std::forward<_Function>(f)(std::move(e), std::get<_I>(std::forward<_Tuple>(t))...);
         }
 
         // For non-void returning functions, apply_impl simply returns function return value (a tuple of values).
@@ -598,10 +714,10 @@ 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, const Error* e, _Tuple&& t)
+    decltype(auto) apply(_Function&& f, std::optional<Error> e, _Tuple&& t)
     {
         return detail::apply_impl( std::forward<_Function>(f)
-                                 , e
+                                 , std::move(e)
                                  , std::forward<_Tuple>(t)
                                  , std::make_index_sequence<std::tuple_size<std::decay_t<_Tuple>>::value>{} );
     }

include/sdbus-c++/Types.h

@@ -29,12 +29,13 @@
 
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/TypeTraits.h>
+
+#include <memory>
 #include <string>
+#include <tuple>
 #include <type_traits>
 #include <typeinfo>
-#include <memory>
-#include <tuple>
-#include <unistd.h>
+#include <utility>
 
 namespace sdbus {
 
@@ -42,7 +43,7 @@ namespace sdbus {
      * @class Variant
      *
      * Variant can hold value of any D-Bus-supported type.
-     * 
+     *
      * Note: Even though thread-aware, Variant objects are not thread-safe.
      * Some const methods are conceptually const, but not physically const,
      * thus are not thread-safe. This is by design: normally, clients
@@ -56,7 +57,7 @@ namespace sdbus {
         Variant();
 
         template <typename _ValueType>
-        Variant(const _ValueType& value)
+        explicit Variant(const _ValueType& value)
             : Variant()
         {
             msg_.openVariant(signature_of<_ValueType>::str());
@@ -104,6 +105,10 @@ namespace sdbus {
      *
      * Representation of struct D-Bus type
      *
+     * Struct implements tuple protocol, i.e. it's a tuple-like class.
+     * It can be used with std::get<>(), std::tuple_element,
+     * std::tuple_size and in structured bindings.
+     *
      ***********************************************/
     template <typename... _ValueTypes>
     class Struct
@@ -112,7 +117,7 @@ namespace sdbus {
     public:
         using std::tuple<_ValueTypes...>::tuple;
 
-        // Disable constructor if an older then 7.1.0 version of GCC is used 
+        // Disable constructor if an older then 7.1.0 version of GCC is used
 #if !((defined(__GNUC__) || defined(__GNUG__)) && !defined(__clang__) && !(__GNUC__ > 7 || (__GNUC__ == 7 && (__GNUC_MINOR__ > 1 || (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ > 0)))))
         Struct() = default;
 
@@ -135,6 +140,9 @@ namespace sdbus {
         }
     };
 
+    template <typename... _Elements>
+    Struct(_Elements...) -> Struct<_Elements...>;
+
     template<typename... _Elements>
     constexpr Struct<std::decay_t<_Elements>...>
     make_struct(_Elements&&... args)
@@ -202,7 +210,7 @@ namespace sdbus {
         UnixFd() = default;
 
         explicit UnixFd(int fd)
-            : fd_(::dup(fd))
+            : fd_(checkedDup(fd))
         {
         }
 
@@ -218,8 +226,12 @@ namespace sdbus {
 
         UnixFd& operator=(const UnixFd& other)
         {
+            if (this == &other)
+            {
+                return *this;
+            }
             close();
-            fd_ = ::dup(other.fd_);
+            fd_ = checkedDup(other.fd_);
             return *this;
         }
 
@@ -230,9 +242,12 @@ namespace sdbus {
 
         UnixFd& operator=(UnixFd&& other)
         {
+            if (this == &other)
+            {
+                return *this;
+            }
             close();
-            fd_ = other.fd_;
-            other.fd_ = -1;
+            fd_ = std::exchange(other.fd_, -1);
             return *this;
         }
 
@@ -241,7 +256,7 @@ namespace sdbus {
             close();
         }
 
-        int get() const
+        [[nodiscard]] int get() const
         {
             return fd_;
         }
@@ -258,26 +273,35 @@ namespace sdbus {
 
         int release()
         {
-            auto fd = fd_;
-            fd_ = -1;
-            return fd;
+            return std::exchange(fd_, -1);
         }
 
-        bool isValid() const
+        [[nodiscard]] bool isValid() const
         {
             return fd_ >= 0;
         }
 
     private:
-        void close()
-        {
-            if (fd_ >= 0)
-                ::close(fd_);
-        }
+        /// Closes file descriptor, but does not set it to -1.
+        void close();
+
+        /// Returns negative argument unchanged.
+        /// Otherwise, call ::dup and throw on failure.
+        static int checkedDup(int fd);
 
         int fd_ = -1;
     };
 
 }
 
+template <size_t _I, typename... _ValueTypes>
+struct std::tuple_element<_I, sdbus::Struct<_ValueTypes...>>
+    : std::tuple_element<_I, std::tuple<_ValueTypes...>>
+{};
+
+template <typename... _ValueTypes>
+struct std::tuple_size<sdbus::Struct<_ValueTypes...>>
+    : std::tuple_size<std::tuple<_ValueTypes...>>
+{};
+
 #endif /* SDBUS_CXX_TYPES_H_ */

include/sdbus-c++/VTableItems.h

@@ -0,0 +1,108 @@
+/**
+ * (C) 2023 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file VTableItems.h
+ *
+ * Created on: Dec 14, 2023
+ * 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_VTABLEITEMS_H_
+#define SDBUS_CXX_VTABLEITEMS_H_
+
+#include <sdbus-c++/Flags.h>
+#include <sdbus-c++/TypeTraits.h>
+
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace sdbus {
+
+    struct MethodVTableItem
+    {
+        template <typename _Function> MethodVTableItem& implementedAs(_Function&& callback);
+        MethodVTableItem& withInputParamNames(std::vector<std::string> names);
+        template <typename... _String> MethodVTableItem& withInputParamNames(_String... names);
+        MethodVTableItem& withOutputParamNames(std::vector<std::string> names);
+        template <typename... _String> MethodVTableItem& withOutputParamNames(_String... names);
+        MethodVTableItem& markAsDeprecated();
+        MethodVTableItem& markAsPrivileged();
+        MethodVTableItem& withNoReply();
+
+        std::string name;
+        std::string inputSignature;
+        std::vector<std::string> inputParamNames;
+        std::string outputSignature;
+        std::vector<std::string> outputParamNames;
+        method_callback callbackHandler;
+        Flags flags;
+    };
+
+    MethodVTableItem registerMethod(std::string methodName);
+
+    struct SignalVTableItem
+    {
+        template <typename... _Args> SignalVTableItem& withParameters();
+        template <typename... _Args> SignalVTableItem& withParameters(std::vector<std::string> names);
+        template <typename... _Args, typename... _String> SignalVTableItem& withParameters(_String... names);
+        SignalVTableItem& markAsDeprecated();
+
+        std::string name;
+        std::string signature;
+        std::vector<std::string> paramNames;
+        Flags flags;
+    };
+
+    SignalVTableItem registerSignal(std::string signalName);
+
+    struct PropertyVTableItem
+    {
+        template <typename _Function> PropertyVTableItem& withGetter(_Function&& callback);
+        template <typename _Function> PropertyVTableItem& withSetter(_Function&& callback);
+        PropertyVTableItem& markAsDeprecated();
+        PropertyVTableItem& markAsPrivileged();
+        PropertyVTableItem& withUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior);
+
+        std::string name;
+        std::string signature;
+        property_get_callback getter;
+        property_set_callback setter;
+        Flags flags;
+    };
+
+    PropertyVTableItem registerProperty(std::string propertyName);
+
+    struct InterfaceFlagsVTableItem
+    {
+        InterfaceFlagsVTableItem& markAsDeprecated();
+        InterfaceFlagsVTableItem& markAsPrivileged();
+        InterfaceFlagsVTableItem& withNoReplyMethods();
+        InterfaceFlagsVTableItem& withPropertyUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior);
+
+        Flags flags;
+    };
+
+    InterfaceFlagsVTableItem setInterfaceFlags();
+
+    using VTableItem = std::variant<MethodVTableItem, SignalVTableItem, PropertyVTableItem, InterfaceFlagsVTableItem>;
+
+} // namespace sdbus
+
+#endif /* SDBUS_CXX_VTABLEITEMS_H_ */

include/sdbus-c++/VTableItems.inl

@@ -0,0 +1,286 @@
+/**
+ * (C) 2023 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file VTableItems.inl
+ *
+ * Created on: Dec 14, 2023
+ * 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_VTABLEITEMS_INL_
+#define SDBUS_CPP_VTABLEITEMS_INL_
+
+#include <sdbus-c++/Error.h>
+#include <sdbus-c++/TypeTraits.h>
+
+#include <string>
+#include <type_traits>
+#include <vector>
+
+namespace sdbus {
+
+    /*** -------------------- ***/
+    /***  Method VTable Item  ***/
+    /*** -------------------- ***/
+
+    template <typename _Function>
+    MethodVTableItem& MethodVTableItem::implementedAs(_Function&& callback)
+    {
+        inputSignature = signature_of_function_input_arguments<_Function>::str();
+        outputSignature = signature_of_function_output_arguments<_Function>::str();
+        callbackHandler = [callback = std::forward<_Function>(callback)](MethodCall call)
+        {
+            // Create a tuple of callback input arguments' types, which will be used
+            // as a storage for the argument values deserialized from the message.
+            tuple_of_function_input_arg_types_t<_Function> inputArgs;
+
+            // Deserialize input arguments from the message into the tuple.
+            call >> inputArgs;
+
+            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 MethodVTableItem& MethodVTableItem::withInputParamNames(std::vector<std::string> names)
+    {
+        inputParamNames = std::move(names);
+
+        return *this;
+    }
+
+    template <typename... _String>
+    inline MethodVTableItem& MethodVTableItem::withInputParamNames(_String... names)
+    {
+        static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
+
+        return withInputParamNames({names...});
+    }
+
+    inline MethodVTableItem& MethodVTableItem::withOutputParamNames(std::vector<std::string> names)
+    {
+        outputParamNames = std::move(names);
+
+        return *this;
+    }
+
+    template <typename... _String>
+    inline MethodVTableItem& MethodVTableItem::withOutputParamNames(_String... names)
+    {
+        static_assert(std::conjunction_v<std::is_convertible<_String, std::string>...>, "Parameter names must be (convertible to) strings");
+
+        return withOutputParamNames({names...});
+    }
+
+    inline MethodVTableItem& MethodVTableItem::markAsDeprecated()
+    {
+        flags.set(Flags::DEPRECATED);
+
+        return *this;
+    }
+
+    inline MethodVTableItem& MethodVTableItem::markAsPrivileged()
+    {
+        flags.set(Flags::PRIVILEGED);
+
+        return *this;
+    }
+
+    inline MethodVTableItem& MethodVTableItem::withNoReply()
+    {
+        flags.set(Flags::METHOD_NO_REPLY);
+
+        return *this;
+    }
+
+    inline MethodVTableItem registerMethod(std::string methodName)
+    {
+        return {std::move(methodName), {}, {}, {}, {}, {}, {}};
+    }
+
+    /*** -------------------- ***/
+    /***  Signal VTable Item  ***/
+    /*** -------------------- ***/
+
+    template <typename... _Args>
+    inline SignalVTableItem& SignalVTableItem::withParameters()
+    {
+        signature = signature_of_function_input_arguments<void(_Args...)>::str();
+
+        return *this;
+    }
+
+    template <typename... _Args>
+    inline SignalVTableItem& SignalVTableItem::withParameters(std::vector<std::string> names)
+    {
+        paramNames = std::move(names);
+
+        return withParameters<_Args...>();
+    }
+
+    template <typename... _Args, typename... _String>
+    inline SignalVTableItem& SignalVTableItem::withParameters(_String... names)
+    {
+        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...>({names...});
+    }
+
+    inline SignalVTableItem& SignalVTableItem::markAsDeprecated()
+    {
+        flags.set(Flags::DEPRECATED);
+
+        return *this;
+    }
+
+    inline SignalVTableItem registerSignal(std::string signalName)
+    {
+        return {std::move(signalName), {}, {}, {}};
+    }
+
+    /*** -------------------- ***/
+    /*** Property VTable Item ***/
+    /*** -------------------- ***/
+
+    template <typename _Function>
+    inline PropertyVTableItem& PropertyVTableItem::withGetter(_Function&& callback)
+    {
+        static_assert(function_argument_count_v<_Function> == 0, "Property getter function must not take any arguments");
+        static_assert(!std::is_void<function_result_t<_Function>>::value, "Property getter function must return property value");
+
+        if (signature.empty())
+            signature = signature_of_function_output_arguments<_Function>::str();
+
+        getter = [callback = std::forward<_Function>(callback)](PropertyGetReply& reply)
+        {
+            // Get the propety value and serialize it into the pre-constructed reply message
+            reply << callback();
+        };
+
+        return *this;
+    }
+
+    template <typename _Function>
+    inline PropertyVTableItem& PropertyVTableItem::withSetter(_Function&& callback)
+    {
+        static_assert(function_argument_count_v<_Function> == 1, "Property setter function must take one parameter - the property value");
+        static_assert(std::is_void<function_result_t<_Function>>::value, "Property setter function must not return any value");
+
+        if (signature.empty())
+            signature = signature_of_function_input_arguments<_Function>::str();
+
+        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 incoming call message
+            call >> property;
+
+            // Invoke setter with the value
+            callback(property);
+        };
+
+        return *this;
+    }
+
+    inline PropertyVTableItem& PropertyVTableItem::markAsDeprecated()
+    {
+        flags.set(Flags::DEPRECATED);
+
+        return *this;
+    }
+
+    inline PropertyVTableItem& PropertyVTableItem::markAsPrivileged()
+    {
+        flags.set(Flags::PRIVILEGED);
+
+        return *this;
+    }
+
+    inline PropertyVTableItem& PropertyVTableItem::withUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior)
+    {
+        flags.set(behavior);
+
+        return *this;
+    }
+
+    inline PropertyVTableItem registerProperty(std::string propertyName)
+    {
+        return {std::move(propertyName), {}, {}, {}, {}};
+    }
+
+    /*** --------------------------- ***/
+    /*** Interface Flags VTable Item ***/
+    /*** --------------------------- ***/
+
+    inline InterfaceFlagsVTableItem& InterfaceFlagsVTableItem::markAsDeprecated()
+    {
+        flags.set(Flags::DEPRECATED);
+
+        return *this;
+    }
+
+    inline InterfaceFlagsVTableItem& InterfaceFlagsVTableItem::markAsPrivileged()
+    {
+        flags.set(Flags::PRIVILEGED);
+
+        return *this;
+    }
+
+    inline InterfaceFlagsVTableItem& InterfaceFlagsVTableItem::withNoReplyMethods()
+    {
+        flags.set(Flags::METHOD_NO_REPLY);
+
+        return *this;
+    }
+
+    inline InterfaceFlagsVTableItem& InterfaceFlagsVTableItem::withPropertyUpdateBehavior(Flags::PropertyUpdateBehaviorFlags behavior)
+    {
+        flags.set(behavior);
+
+        return *this;
+    }
+
+    inline InterfaceFlagsVTableItem setInterfaceFlags()
+    {
+        return {};
+    }
+
+} // namespace sdbus
+
+#endif /* SDBUS_CPP_VTABLEITEMS_INL_ */

pkgconfig/sdbus-c++.pc.in

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

src/Connection.h

@@ -27,18 +27,21 @@
 #ifndef SDBUS_CXX_INTERNAL_CONNECTION_H_
 #define SDBUS_CXX_INTERNAL_CONNECTION_H_
 
-#include <sdbus-c++/IConnection.h>
-#include <sdbus-c++/Message.h>
+#include "sdbus-c++/IConnection.h"
+
+#include "sdbus-c++/Message.h"
+
 #include "IConnection.h"
-#include "ScopeGuard.h"
 #include "ISdBus.h"
-#include <systemd/sd-bus.h>
+#include "ScopeGuard.h"
+
 #include <memory>
-#include <thread>
 #include <string>
+#include SDBUS_HEADER
+#include <thread>
 #include <vector>
-#include <atomic>
-#include <mutex>
+
+struct sd_event_source;
 
 namespace sdbus::internal {
 
@@ -57,6 +60,12 @@ namespace sdbus::internal {
         inline static constexpr custom_session_bus_t custom_session_bus{};
         struct remote_system_bus_t{};
         inline static constexpr remote_system_bus_t remote_system_bus{};
+        struct private_bus_t{};
+        inline static constexpr private_bus_t private_bus{};
+        struct server_bus_t{};
+        inline static constexpr server_bus_t server_bus{};
+        struct sdbus_bus_t{}; // A bus connection created directly from existing sd_bus instance
+        inline static constexpr sdbus_bus_t sdbus_bus{};
         struct pseudo_bus_t{}; // A bus connection that is not really established with D-Bus daemon
         inline static constexpr pseudo_bus_t pseudo_bus{};
 
@@ -65,44 +74,58 @@ namespace sdbus::internal {
         Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t);
         Connection(std::unique_ptr<ISdBus>&& interface, custom_session_bus_t, const std::string& address);
         Connection(std::unique_ptr<ISdBus>&& interface, remote_system_bus_t, const std::string& host);
+        Connection(std::unique_ptr<ISdBus>&& interface, private_bus_t, const std::string& address);
+        Connection(std::unique_ptr<ISdBus>&& interface, private_bus_t, int fd);
+        Connection(std::unique_ptr<ISdBus>&& interface, server_bus_t, int fd);
+        Connection(std::unique_ptr<ISdBus>&& interface, sdbus_bus_t, sd_bus *bus);
         Connection(std::unique_ptr<ISdBus>&& interface, pseudo_bus_t);
         ~Connection() override;
 
         void requestName(const std::string& name) override;
         void releaseName(const std::string& name) override;
-        std::string getUniqueName() const override;
+        [[nodiscard]] std::string getUniqueName() const override;
         void enterEventLoop() override;
         void enterEventLoopAsync() override;
         void leaveEventLoop() override;
-        PollData getEventLoopPollData() const override;
-        bool processPendingRequest() override;
+        [[nodiscard]] PollData getEventLoopPollData() const override;
+        bool processPendingEvent() override;
+        Message getCurrentlyProcessedMessage() const override;
 
-        void addObjectManager(const std::string& objectPath) override;
         void addObjectManager(const std::string& objectPath, floating_slot_t) override;
-        Slot addObjectManager(const std::string& objectPath, request_slot_t) override;
+        Slot addObjectManager(const std::string& objectPath, return_slot_t) override;
 
         void setMethodCallTimeout(uint64_t timeout) override;
-        uint64_t getMethodCallTimeout() const override;
+        [[nodiscard]] uint64_t getMethodCallTimeout() const override;
 
         [[nodiscard]] Slot addMatch(const std::string& match, message_handler callback) override;
         void addMatch(const std::string& match, message_handler callback, floating_slot_t) override;
+        [[nodiscard]] Slot addMatchAsync(const std::string& match, message_handler callback, message_handler installCallback) override;
+        void addMatchAsync(const std::string& match, message_handler callback, message_handler installCallback, floating_slot_t) override;
 
-        const ISdBus& getSdBusInterface() const override;
-        ISdBus& getSdBusInterface() override;
+        void attachSdEventLoop(sd_event *event, int priority) override;
+        void detachSdEventLoop() override;
+        sd_event *getSdEventLoop() override;
+
+        [[nodiscard]] const ISdBus& getSdBusInterface() const override;
+        [[nodiscard]] ISdBus& getSdBusInterface() override;
 
         Slot addObjectVTable( const std::string& objectPath
                             , const std::string& interfaceName
                             , const sd_bus_vtable* vtable
                             , void* userData ) override;
 
-        PlainMessage createPlainMessage() const override;
-        MethodCall createMethodCall( const std::string& destination
-                                   , const std::string& objectPath
-                                   , const std::string& interfaceName
-                                   , const std::string& methodName ) const override;
-        Signal createSignal( const std::string& objectPath
-                           , const std::string& interfaceName
-                           , const std::string& signalName ) const override;
+        [[nodiscard]] PlainMessage createPlainMessage() const override;
+        [[nodiscard]] MethodCall createMethodCall( const std::string& destination
+                                                 , const std::string& objectPath
+                                                 , const std::string& interfaceName
+                                                 , const std::string& methodName ) const override;
+        [[nodiscard]] Signal createSignal( const std::string& objectPath
+                                         , const std::string& interfaceName
+                                         , const std::string& signalName ) const override;
+
+        MethodReply callMethod(const MethodCall& message, uint64_t timeout) override;
+        void callMethod(const MethodCall& message, void* callback, void* userData, uint64_t timeout, floating_slot_t) override;
+        Slot callMethod(const MethodCall& message, void* callback, void* userData, uint64_t timeout) override;
 
         void emitPropertiesChangedSignal( const std::string& objectPath
                                         , const std::string& interfaceName
@@ -121,8 +144,6 @@ namespace sdbus::internal {
                                   , sd_bus_message_handler_t callback
                                   , void* userData ) override;
 
-        MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) override;
-
     private:
         using BusFactory = std::function<int(sd_bus**)>;
         using BusPtr = std::unique_ptr<sd_bus, std::function<sd_bus*(sd_bus*)>>;
@@ -131,44 +152,69 @@ namespace sdbus::internal {
         BusPtr openBus(const std::function<int(sd_bus**)>& busFactory);
         BusPtr openPseudoBus();
         void finishHandshake(sd_bus* bus);
-        bool waitForNextRequest();
-        static std::string composeSignalMatchFilter( const std::string &sender
-                                                   , const std::string &objectPath
-                                                   , const std::string &interfaceName
-                                                   , const std::string &signalName);
-        void notifyEventLoop(int fd) const;
-        void notifyEventLoopToExit() const;
-        void clearEventLoopNotification(int fd) const;
-        void notifyEventLoopNewTimeout() const override;
+        bool waitForNextEvent();
+
+        [[nodiscard]] bool arePendingMessagesInReadQueue() const;
+
+        void notifyEventLoopToExit();
+        void notifyEventLoopToWakeUpFromPoll();
+        void wakeUpEventLoopIfMessagesInQueue();
+        void joinWithEventLoop();
+
+        static std::vector</*const */char*> to_strv(const std::vector<std::string>& strings);
+
+        static int sdbus_match_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
+        static int sdbus_match_install_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
 
     private:
-        void joinWithEventLoop();
-        static std::vector</*const */char*> to_strv(const std::vector<std::string>& strings);
+#ifndef SDBUS_basu // sd_event integration is not supported if instead of libsystemd we are based on basu
+        Slot createSdEventSlot(sd_event *event);
+        Slot createSdTimeEventSourceSlot(sd_event *event, int priority);
+        Slot createSdIoEventSourceSlot(sd_event *event, int fd, int priority);
+        Slot createSdInternalEventSourceSlot(sd_event *event, int fd, int priority);
+        static void deleteSdEventSource(sd_event_source *s);
+
+        static int onSdTimerEvent(sd_event_source *s, uint64_t usec, void *userdata);
+        static int onSdIoEvent(sd_event_source *s, int fd, uint32_t revents, void *userdata);
+        static int onSdInternalEvent(sd_event_source *s, int fd, uint32_t revents, void *userdata);
+        static int onSdEventPrepare(sd_event_source *s, void *userdata);
+#endif
 
         struct EventFd
         {
             EventFd();
             ~EventFd();
+            void notify();
+            bool clear();
+
             int fd{-1};
         };
 
         struct MatchInfo
         {
             message_handler callback;
+            message_handler installCallback;
             Connection& connection;
-            sd_bus_slot *slot;
+            Slot slot;
+        };
+
+        // sd-event integration
+        struct SdEvent
+        {
+            Slot sdEvent;
+            Slot sdTimeEventSource;
+            Slot sdIoEventSource;
+            Slot sdInternalEventSource;
         };
 
     private:
-        std::unique_ptr<ISdBus> iface_;
+        std::unique_ptr<ISdBus> sdbus_;
         BusPtr bus_;
         std::thread asyncLoopThread_;
-        std::atomic<std::thread::id> loopThreadId_;
-        std::mutex loopMutex_;
-        EventFd loopExitFd_;
-        EventFd eventFd_;
-        std::atomic<uint64_t> activeTimeout_{};
+        EventFd loopExitFd_; // To wake up event loop I/O polling to exit
+        EventFd eventFd_; // To wake up event loop I/O polling to re-enter poll with fresh PollData values
         std::vector<Slot> floatingMatchRules_;
+        std::unique_ptr<SdEvent> sdEvent_; // Integration of systemd sd-event event loop implementation
     };
 
 }

src/Error.cpp

@@ -24,10 +24,12 @@
  * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <sdbus-c++/Error.h>
-#include <systemd/sd-bus.h>
+#include "sdbus-c++/Error.h"
+
 #include "ScopeGuard.h"
 
+#include SDBUS_HEADER
+
 namespace sdbus
 {
     sdbus::Error createError(int errNo, const std::string& customMsg)
@@ -40,4 +42,4 @@ namespace sdbus
         std::string message(customMsg + " (" + sdbusError.message + ")");
         return sdbus::Error(name, message);
     }
-}
+} // namespace sdbus

src/Flags.cpp

@@ -25,7 +25,7 @@
  */
 
 #include <sdbus-c++/Flags.h>
-#include <systemd/sd-bus.h>
+#include SDBUS_HEADER
 
 namespace sdbus
 {
@@ -47,7 +47,7 @@ namespace sdbus
             sdbusFlags |= SD_BUS_VTABLE_PROPERTY_CONST;
         else if (flags_.test(Flags::EMITS_NO_SIGNAL))
             sdbusFlags |= 0;
-        
+
         return sdbusFlags;
     }
 

src/IConnection.h

@@ -27,11 +27,14 @@
 #ifndef SDBUS_CXX_INTERNAL_ICONNECTION_H_
 #define SDBUS_CXX_INTERNAL_ICONNECTION_H_
 
-#include <sdbus-c++/IConnection.h>
-#include <systemd/sd-bus.h>
-#include <string>
-#include <memory>
+#include "sdbus-c++/IConnection.h"
+
+#include "sdbus-c++/TypeTraits.h"
+
 #include <functional>
+#include <memory>
+#include <string>
+#include SDBUS_HEADER
 #include <vector>
 
 // Forward declaration
@@ -53,22 +56,26 @@ namespace sdbus::internal {
     public:
         ~IConnection() override = default;
 
-        virtual const ISdBus& getSdBusInterface() const = 0;
-        virtual ISdBus& getSdBusInterface() = 0;
+        [[nodiscard]] virtual const ISdBus& getSdBusInterface() const = 0;
+        [[nodiscard]] virtual ISdBus& getSdBusInterface() = 0;
 
         [[nodiscard]] virtual Slot addObjectVTable( const std::string& objectPath
                                                   , const std::string& interfaceName
                                                   , const sd_bus_vtable* vtable
                                                   , void* userData ) = 0;
 
-        virtual PlainMessage createPlainMessage() const = 0;
-        virtual MethodCall createMethodCall( const std::string& destination
-                                           , const std::string& objectPath
-                                           , const std::string& interfaceName
-                                           , const std::string& methodName ) const = 0;
-        virtual Signal createSignal( const std::string& objectPath
-                                   , const std::string& interfaceName
-                                   , const std::string& signalName ) const = 0;
+        [[nodiscard]] virtual PlainMessage createPlainMessage() const = 0;
+        [[nodiscard]] virtual MethodCall createMethodCall( const std::string& destination
+                                                         , const std::string& objectPath
+                                                         , const std::string& interfaceName
+                                                         , const std::string& methodName ) const = 0;
+        [[nodiscard]] virtual Signal createSignal( const std::string& objectPath
+                                                 , const std::string& interfaceName
+                                                 , const std::string& signalName ) const = 0;
+
+        virtual MethodReply callMethod(const MethodCall& message, uint64_t timeout) = 0;
+        virtual void callMethod(const MethodCall& message, void* callback, void* userData, uint64_t timeout, floating_slot_t) = 0;
+        [[nodiscard]] virtual Slot callMethod(const MethodCall& message, void* callback, void* userData, uint64_t timeout) = 0;
 
         virtual void emitPropertiesChangedSignal( const std::string& objectPath
                                                 , const std::string& interfaceName
@@ -81,7 +88,7 @@ namespace sdbus::internal {
                                                 , const std::vector<std::string>& interfaces ) = 0;
 
         using sdbus::IConnection::addObjectManager;
-        [[nodiscard]] virtual Slot addObjectManager(const std::string& objectPath, request_slot_t) = 0;
+        [[nodiscard]] virtual Slot addObjectManager(const std::string& objectPath, return_slot_t) = 0;
 
         [[nodiscard]] virtual Slot registerSignalHandler( const std::string& sender
                                                         , const std::string& objectPath
@@ -89,12 +96,8 @@ namespace sdbus::internal {
                                                         , const std::string& signalName
                                                         , sd_bus_message_handler_t callback
                                                         , void* userData ) = 0;
-
-        virtual void notifyEventLoopNewTimeout() const = 0;
-        virtual MethodReply tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout) = 0;
     };
 
-    [[nodiscard]] std::unique_ptr<sdbus::internal::IConnection> createConnection();
     [[nodiscard]] std::unique_ptr<sdbus::internal::IConnection> createPseudoConnection();
 
 }

src/ISdBus.h

@@ -28,7 +28,7 @@
 #ifndef SDBUS_CXX_ISDBUS_H
 #define SDBUS_CXX_ISDBUS_H
 
-#include <systemd/sd-bus.h>
+#include SDBUS_HEADER
 
 namespace sdbus::internal {
 
@@ -71,20 +71,26 @@ namespace sdbus::internal {
         virtual int sd_bus_open_user(sd_bus **ret) = 0;
         virtual int sd_bus_open_user_with_address(sd_bus **ret, const char* address) = 0;
         virtual int sd_bus_open_system_remote(sd_bus **ret, const char* host) = 0;
+        virtual int sd_bus_open_direct(sd_bus **ret, const char* address) = 0;
+        virtual int sd_bus_open_direct(sd_bus **ret, int fd) = 0;
+        virtual int sd_bus_open_server(sd_bus **ret, int fd) = 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 int sd_bus_add_match_async(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata) = 0;
+        virtual int sd_bus_match_signal(sd_bus *bus, sd_bus_slot **ret, const char *sender, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata) = 0;
         virtual sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) = 0;
 
         virtual int sd_bus_new(sd_bus **ret) = 0;
         virtual int sd_bus_start(sd_bus *bus) = 0;
 
         virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) = 0;
+        virtual sd_bus_message* sd_bus_get_current_message(sd_bus *bus) = 0;
         virtual int sd_bus_get_poll_data(sd_bus *bus, PollData* data) = 0;
-
+        virtual int sd_bus_get_n_queued_read(sd_bus *bus, uint64_t *ret) = 0;
         virtual int sd_bus_flush(sd_bus *bus) = 0;
         virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) = 0;
         virtual sd_bus *sd_bus_close_unref(sd_bus *bus) = 0;

src/Message.cpp

@@ -24,15 +24,18 @@
  * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <sdbus-c++/Message.h>
-#include <sdbus-c++/Types.h>
-#include <sdbus-c++/Error.h>
-#include "MessageUtils.h"
-#include "ISdBus.h"
+#include "sdbus-c++/Message.h"
+
+#include "sdbus-c++/Error.h"
+#include "sdbus-c++/Types.h"
+
 #include "IConnection.h"
+#include "ISdBus.h"
+#include "MessageUtils.h"
 #include "ScopeGuard.h"
-#include <systemd/sd-bus.h>
+
 #include <cassert>
+#include SDBUS_HEADER
 
 namespace sdbus {
 
@@ -226,6 +229,13 @@ Message& Message::operator<<(const UnixFd &item)
     return *this;
 }
 
+Message& Message::appendArray(char type, const void *ptr, size_t size)
+{
+    auto r = sd_bus_message_append_array((sd_bus_message*)msg_, type, ptr, size);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to serialize an array", -r);
+
+    return *this;
+}
 
 Message& Message::operator>>(bool& item)
 {
@@ -318,6 +328,17 @@ Message& Message::operator>>(uint64_t& item)
     return *this;
 }
 
+Message& Message::readArray(char type, const void **ptr, size_t *size)
+{
+    auto r = sd_bus_message_read_array((sd_bus_message*)msg_, type, ptr, size);
+    if (r == 0)
+        ok_ = false;
+
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to deserialize an array", -r);
+
+    return *this;
+}
+
 Message& Message::operator>>(double& item)
 {
     auto r = sd_bus_message_read_basic((sd_bus_message*)msg_, SD_BUS_TYPE_DOUBLE, &item);
@@ -630,6 +651,11 @@ bool Message::isEmpty() const
     return sd_bus_message_is_empty((sd_bus_message*)msg_) != 0;
 }
 
+bool Message::isAtEnd(bool complete) const
+{
+    return sd_bus_message_at_end((sd_bus_message*)msg_, complete) > 0;
+}
+
 pid_t Message::getCredsPid() const
 {
     uint64_t mask = SD_BUS_CREDS_PID | SD_BUS_CREDS_AUGMENT;
@@ -740,12 +766,9 @@ std::string Message::getSELinuxContext() const
 
 MethodCall::MethodCall( void *msg
                       , internal::ISdBus *sdbus
-                      , const internal::IConnection *connection
                       , adopt_message_t) noexcept
    : Message(msg, sdbus, adopt_message)
-   , connection_(connection)
 {
-    assert(connection_ != nullptr);
 }
 
 void MethodCall::dontExpectReply()
@@ -793,19 +816,10 @@ MethodReply MethodCall::sendWithNoReply() const
     return Factory::create<MethodReply>(); // No reply
 }
 
-void MethodCall::send(void* callback, void* userData, uint64_t timeout, dont_request_slot_t) const
-{
-    MethodCall::send(callback, userData, timeout, floating_slot);
-}
-
 void MethodCall::send(void* callback, void* userData, uint64_t timeout, floating_slot_t) const
 {
     auto r = sdbus_->sd_bus_call_async(nullptr, nullptr, (sd_bus_message*)msg_, (sd_bus_message_handler_t)callback, userData, timeout);
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to call method", -r);
-
-    // Force event loop to re-enter polling with the async call timeout if that is less than the one used in current poll
-    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
-    connection_->notifyEventLoopNewTimeout();
 }
 
 Slot MethodCall::send(void* callback, void* userData, uint64_t timeout) const
@@ -815,10 +829,6 @@ Slot MethodCall::send(void* callback, void* userData, uint64_t timeout) const
     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);
 
-    // Force event loop to re-enter polling with the async call timeout if that is less than the one used in current poll
-    SDBUS_THROW_ERROR_IF(connection_ == nullptr, "Invalid use of MethodCall API", ENOTSUP);
-    connection_->notifyEventLoopNewTimeout();
-
     return {slot, [sdbus_ = sdbus_](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }
 
@@ -862,15 +872,57 @@ void Signal::setDestination(const std::string& destination)
     SDBUS_THROW_ERROR_IF(r < 0, "Failed to set signal destination", -r);
 }
 
+namespace {
+
+// Pseudo-connection lifetime handling. In standard cases, we could do with simply function-local static pseudo
+// connection instance below. However, it may happen that client's sdbus-c++ objects outlive this static connection
+// instance (because they are used in global application objects that were created before this connection, and thus
+// are destroyed later). This by itself sounds like a smell in client's application design, but it is downright bad
+// in sdbus-c++ because it has no control over when client's dependent statics get destroyed. A "Phoenix" pattern
+// (see Modern C++ Design - Generic Programming and Design Patterns Applied, by Andrei Alexandrescu) is applied to fix
+// this by re-creating the connection again in such cases and keeping it alive until the next exit handler is invoked.
+// Please note that the solution is NOT thread-safe.
+// Another common solution is global sdbus-c++ startup/shutdown functions, but that would be an intrusive change.
+
+/*constinit (C++20 keyword) */ static bool pseudoConnectionDestroyed{};
+
+std::unique_ptr<sdbus::internal::IConnection, void(*)(sdbus::internal::IConnection*)> createPseudoConnection()
+{
+    auto deleter = [](sdbus::internal::IConnection* con)
+    {
+        delete con;
+        pseudoConnectionDestroyed = true;
+    };
+
+    return {internal::createPseudoConnection().release(), std::move(deleter)};
+}
+
+sdbus::internal::IConnection& getPseudoConnectionInstance()
+{
+    static auto connection = createPseudoConnection();
+
+    if (pseudoConnectionDestroyed)
+    {
+        connection = createPseudoConnection(); // Phoenix rising from the ashes
+        atexit([](){ connection.~unique_ptr(); }); // We have to manually take care of deleting the phoenix
+        pseudoConnectionDestroyed = false;
+    }
+
+    assert(connection != nullptr);
+
+    return *connection;
+}
+
+}
+
 PlainMessage createPlainMessage()
 {
-    //static auto connection = internal::createConnection();
     // Let's create a pseudo connection -- one that does not really connect to the real bus.
     // This is a bit of a hack, but it enables use to work with D-Bus message locally without
     // the need of D-Bus daemon. This is especially useful in unit tests of both sdbus-c++ and client code.
     // Additionally, it's light-weight and fast solution.
-    static auto connection = internal::createPseudoConnection();
-    return connection->createPlainMessage();
+    auto& connection = getPseudoConnectionInstance();
+    return connection.createPlainMessage();
 }
 
 }

src/MessageUtils.h

@@ -57,12 +57,6 @@ namespace sdbus
         {
             return _Msg{msg, sdbus, adopt_message};
         }
-
-        template<typename _Msg>
-        static _Msg create(void *msg, internal::ISdBus* sdbus, const internal::IConnection* connection, adopt_message_t)
-        {
-            return _Msg{msg, sdbus, connection, adopt_message};
-        }
     };
 
     PlainMessage createPlainMessage();

src/Object.cpp

@@ -25,19 +25,21 @@
  */
 
 #include "Object.h"
-#include "MessageUtils.h"
-#include <sdbus-c++/IConnection.h>
-#include <sdbus-c++/Message.h>
-#include <sdbus-c++/Error.h>
-#include <sdbus-c++/MethodResult.h>
-#include <sdbus-c++/Flags.h>
-#include "ScopeGuard.h"
+
+#include "sdbus-c++/Error.h"
+#include "sdbus-c++/Flags.h"
+#include "sdbus-c++/IConnection.h"
+#include "sdbus-c++/Message.h"
+
 #include "IConnection.h"
+#include "MessageUtils.h"
+#include "ScopeGuard.h"
 #include "Utils.h"
 #include "VTableUtils.h"
-#include <systemd/sd-bus.h>
-#include <utility>
+
 #include <cassert>
+#include SDBUS_HEADER
+#include <utility>
 
 namespace sdbus::internal {
 
@@ -47,129 +49,33 @@ Object::Object(sdbus::internal::IConnection& connection, std::string objectPath)
     SDBUS_CHECK_OBJECT_PATH(objectPath_);
 }
 
-void Object::registerMethod( const std::string& interfaceName
-                           , std::string methodName
-                           , std::string inputSignature
-                           , std::string outputSignature
-                           , method_callback methodCallback
-                           , Flags flags )
+void Object::addVTable(std::string interfaceName, std::vector<VTableItem> vtable)
 {
-    registerMethod( interfaceName
-                  , std::move(methodName)
-                  , std::move(inputSignature)
-                  , {}
-                  , std::move(outputSignature)
-                  , {}
-                  , std::move(methodCallback)
-                  , std::move(flags) );
+    auto slot = Object::addVTable(std::move(interfaceName), std::move(vtable), return_slot);
+
+    vtables_.push_back(std::move(slot));
 }
 
-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 )
+Slot Object::addVTable(std::string interfaceName, std::vector<VTableItem> vtable, return_slot_t)
 {
     SDBUS_CHECK_INTERFACE_NAME(interfaceName);
-    SDBUS_CHECK_MEMBER_NAME(methodName);
-    SDBUS_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);
 
-    auto& interface = getInterface(interfaceName);
-    InterfaceData::MethodData methodData{ std::move(inputSignature)
-                                        , std::move(outputSignature)
-                                        , paramNamesToString(inputNames) + paramNamesToString(outputNames)
-                                        , std::move(methodCallback)
-                                        , std::move(flags) };
-    auto inserted = interface.methods.emplace(std::move(methodName), std::move(methodData)).second;
+    // 1st pass -- create vtable structure for internal sdbus-c++ purposes
+    auto internalVTable = std::make_unique<VTable>(createInternalVTable(std::move(interfaceName), std::move(vtable)));
 
-    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
-}
+    // 2nd pass -- from internal sdbus-c++ vtable, create vtable structure in format expected by underlying sd-bus library
+    internalVTable->sdbusVTable = createInternalSdBusVTable(*internalVTable);
 
-void Object::registerSignal( const std::string& interfaceName
-                           , std::string signalName
-                           , std::string signature
-                           , Flags flags )
-{
-    registerSignal(interfaceName, std::move(signalName), std::move(signature), {}, std::move(flags));
-}
+    // 3rd step -- register the vtable with sd-bus
+    internalVTable->slot = connection_.addObjectVTable(objectPath_, internalVTable->interfaceName, &internalVTable->sdbusVTable[0], internalVTable.get());
 
-void Object::registerSignal( const std::string& interfaceName
-                           , std::string signalName
-                           , std::string signature
-                           , const std::vector<std::string>& paramNames
-                           , Flags flags )
-{
-    SDBUS_CHECK_INTERFACE_NAME(interfaceName);
-    SDBUS_CHECK_MEMBER_NAME(signalName);
-
-    auto& interface = getInterface(interfaceName);
-
-    InterfaceData::SignalData signalData{std::move(signature), paramNamesToString(paramNames), std::move(flags)};
-    auto inserted = interface.signals.emplace(std::move(signalName), std::move(signalData)).second;
-
-    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register signal: signal already exists", EINVAL);
-}
-
-void Object::registerProperty( const std::string& interfaceName
-                             , std::string propertyName
-                             , std::string signature
-                             , property_get_callback getCallback
-                             , Flags flags )
-{
-    registerProperty( interfaceName
-                    , std::move(propertyName)
-                    , std::move(signature)
-                    , std::move(getCallback)
-                    , {}
-                    , std::move(flags) );
-}
-
-void Object::registerProperty( const std::string& interfaceName
-                             , std::string propertyName
-                             , std::string signature
-                             , property_get_callback getCallback
-                             , property_set_callback setCallback
-                             , Flags flags )
-{
-    SDBUS_CHECK_INTERFACE_NAME(interfaceName);
-    SDBUS_CHECK_MEMBER_NAME(propertyName);
-    SDBUS_THROW_ERROR_IF(!getCallback && !setCallback, "Invalid property callbacks provided", EINVAL);
-
-    auto& interface = getInterface(interfaceName);
-
-    InterfaceData::PropertyData propertyData{ std::move(signature)
-                                            , std::move(getCallback)
-                                            , std::move(setCallback)
-                                            , std::move(flags) };
-    auto inserted = interface.properties.emplace(std::move(propertyName), std::move(propertyData)).second;
-
-    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register property: property already exists", EINVAL);
-}
-
-void Object::setInterfaceFlags(const std::string& interfaceName, Flags flags)
-{
-    auto& interface = getInterface(interfaceName);
-    interface.flags = flags;
-}
-
-void Object::finishRegistration()
-{
-    for (auto& item : interfaces_)
-    {
-        const auto& interfaceName = item.first;
-        auto& interfaceData = item.second;
-
-        const auto& vtable = createInterfaceVTable(interfaceData);
-        activateInterfaceVTable(interfaceName, interfaceData, vtable);
-    }
+    // Return vtable wrapped in a Slot object
+    return {internalVTable.release(), [](void *ptr){ delete static_cast<VTable*>(ptr); }};
 }
 
 void Object::unregister()
 {
-    interfaces_.clear();
+    vtables_.clear();
     removeObjectManager();
 }
 
@@ -217,7 +123,7 @@ void Object::emitInterfacesRemovedSignal(const std::vector<std::string>& interfa
 
 void Object::addObjectManager()
 {
-    objectManagerSlot_ = connection_.addObjectManager(objectPath_, request_slot);
+    objectManagerSlot_ = connection_.addObjectManager(objectPath_, return_slot);
 }
 
 void Object::removeObjectManager()
@@ -240,86 +146,156 @@ const std::string& Object::getObjectPath() const
     return objectPath_;
 }
 
-const Message* Object::getCurrentlyProcessedMessage() const
+Message Object::getCurrentlyProcessedMessage() const
 {
-    return m_CurrentlyProcessedMessage.load(std::memory_order_relaxed);
+    return connection_.getCurrentlyProcessedMessage();
 }
 
-Object::InterfaceData& Object::getInterface(const std::string& interfaceName)
+Object::VTable Object::createInternalVTable(std::string interfaceName, std::vector<VTableItem> vtable)
 {
-    return interfaces_.emplace(interfaceName, *this).first->second;
-}
+    VTable internalVTable;
 
-const std::vector<sd_bus_vtable>& Object::createInterfaceVTable(InterfaceData& interfaceData)
-{
-    auto& vtable = interfaceData.vtable;
-    assert(vtable.empty());
+    internalVTable.interfaceName = std::move(interfaceName);
 
-    vtable.push_back(createVTableStartItem(interfaceData.flags.toSdBusInterfaceFlags()));
-    registerMethodsToVTable(interfaceData, vtable);
-    registerSignalsToVTable(interfaceData, vtable);
-    registerPropertiesToVTable(interfaceData, vtable);
-    vtable.push_back(createVTableEndItem());
-
-    return vtable;
-}
-
-void Object::registerMethodsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
-{
-    for (const auto& item : interfaceData.methods)
+    for (auto& vtableItem : vtable)
     {
-        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.paramNames.c_str()
-                                               , &Object::sdbus_method_callback
-                                               , methodData.flags.toSdBusMethodFlags() ));
+        std::visit( overload{ [&](InterfaceFlagsVTableItem&& interfaceFlags){ writeInterfaceFlagsToVTable(std::move(interfaceFlags), internalVTable); }
+                            , [&](MethodVTableItem&& method){ writeMethodRecordToVTable(std::move(method), internalVTable); }
+                            , [&](SignalVTableItem&& signal){ writeSignalRecordToVTable(std::move(signal), internalVTable); }
+                            , [&](PropertyVTableItem&& property){ writePropertyRecordToVTable(std::move(property), internalVTable); } }
+                  , std::move(vtableItem) );
     }
+
+    // Sort arrays so we can do fast searching for an item in sd-bus callback handlers
+    std::sort(internalVTable.methods.begin(), internalVTable.methods.end(), [](const auto& a, const auto& b){ return a.name < b.name; });
+    std::sort(internalVTable.signals.begin(), internalVTable.signals.end(), [](const auto& a, const auto& b){ return a.name < b.name; });
+    std::sort(internalVTable.properties.begin(), internalVTable.properties.end(), [](const auto& a, const auto& b){ return a.name < b.name; });
+
+    internalVTable.object = this;
+
+    return internalVTable;
 }
 
-void Object::registerSignalsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
+void Object::writeInterfaceFlagsToVTable(InterfaceFlagsVTableItem flags, VTable& vtable)
 {
-    for (const auto& item : interfaceData.signals)
+    vtable.interfaceFlags = std::move(flags.flags);
+}
+
+void Object::writeMethodRecordToVTable(MethodVTableItem method, VTable& vtable)
+{
+    SDBUS_CHECK_MEMBER_NAME(method.name);
+    SDBUS_THROW_ERROR_IF(!method.callbackHandler, "Invalid method callback provided", EINVAL);
+
+    vtable.methods.push_back({ std::move(method.name)
+                             , std::move(method.inputSignature)
+                             , std::move(method.outputSignature)
+                             , paramNamesToString(method.inputParamNames) + paramNamesToString(method.outputParamNames)
+                             , std::move(method.callbackHandler)
+                             , std::move(method.flags) });
+}
+
+void Object::writeSignalRecordToVTable(SignalVTableItem signal, VTable& vtable)
+{
+    SDBUS_CHECK_MEMBER_NAME(signal.name);
+
+    vtable.signals.push_back({ std::move(signal.name)
+                             , std::move(signal.signature)
+                             , paramNamesToString(signal.paramNames)
+                             , std::move(signal.flags) });
+}
+
+void Object::writePropertyRecordToVTable(PropertyVTableItem property, VTable& vtable)
+{
+    SDBUS_CHECK_MEMBER_NAME(property.name);
+    SDBUS_THROW_ERROR_IF(!property.getter && !property.setter, "Invalid property callbacks provided", EINVAL);
+
+    vtable.properties.push_back({ std::move(property.name)
+                                , std::move(property.signature)
+                                , std::move(property.getter)
+                                , std::move(property.setter)
+                                , std::move(property.flags) });
+}
+
+std::vector<sd_bus_vtable> Object::createInternalSdBusVTable(const VTable& vtable)
+{
+    std::vector<sd_bus_vtable> sdbusVTable;
+
+    startSdBusVTable(vtable.interfaceFlags, sdbusVTable);
+    for (const auto& methodItem : vtable.methods)
+        writeMethodRecordToSdBusVTable(methodItem, sdbusVTable);
+    for (const auto& signalItem : vtable.signals)
+        writeSignalRecordToSdBusVTable(signalItem, sdbusVTable);
+    for (const auto& propertyItem : vtable.properties)
+        writePropertyRecordToSdBusVTable(propertyItem, sdbusVTable);
+    finalizeSdBusVTable(sdbusVTable);
+
+    return sdbusVTable;
+}
+
+void Object::startSdBusVTable(const Flags& interfaceFlags, std::vector<sd_bus_vtable>& vtable)
+{
+    auto vtableItem = createSdBusVTableStartItem(interfaceFlags.toSdBusInterfaceFlags());
+    vtable.push_back(std::move(vtableItem));
+}
+
+void Object::writeMethodRecordToSdBusVTable(const VTable::MethodItem& method, std::vector<sd_bus_vtable>& vtable)
+{
+    auto vtableItem = createSdBusVTableMethodItem( method.name.c_str()
+                                                 , method.inputArgs.c_str()
+                                                 , method.outputArgs.c_str()
+                                                 , method.paramNames.c_str()
+                                                 , &Object::sdbus_method_callback
+                                                 , method.flags.toSdBusMethodFlags() );
+    vtable.push_back(std::move(vtableItem));
+}
+
+void Object::writeSignalRecordToSdBusVTable(const VTable::SignalItem& signal, std::vector<sd_bus_vtable>& vtable)
+{
+    auto vtableItem = createSdBusVTableSignalItem( signal.name.c_str()
+                                                 , signal.signature.c_str()
+                                                 , signal.paramNames.c_str()
+                                                 , signal.flags.toSdBusSignalFlags() );
+    vtable.push_back(std::move(vtableItem));
+}
+
+void Object::writePropertyRecordToSdBusVTable(const VTable::PropertyItem& property, std::vector<sd_bus_vtable>& vtable)
+{
+    auto vtableItem = !property.setCallback
+                    ? createSdBusVTableReadOnlyPropertyItem( property.name.c_str()
+                                                           , property.signature.c_str()
+                                                           , &Object::sdbus_property_get_callback
+                                                           , property.flags.toSdBusPropertyFlags() )
+                    : createSdBusVTableWritablePropertyItem( property.name.c_str()
+                                                           , property.signature.c_str()
+                                                           , &Object::sdbus_property_get_callback
+                                                           , &Object::sdbus_property_set_callback
+                                                           , property.flags.toSdBusWritablePropertyFlags() );
+    vtable.push_back(std::move(vtableItem));
+}
+
+void Object::finalizeSdBusVTable(std::vector<sd_bus_vtable>& vtable)
+{
+    vtable.push_back(createSdBusVTableEndItem());
+}
+
+const Object::VTable::MethodItem* Object::findMethod(const VTable& vtable, const std::string& methodName)
+{
+    auto it = std::lower_bound(vtable.methods.begin(), vtable.methods.end(), methodName, [](const auto& methodItem, const auto& methodName)
     {
-        const auto& signalName = item.first;
-        const auto& signalData = item.second;
+        return methodItem.name < methodName;
+    });
 
-        vtable.push_back(createVTableSignalItem( signalName.c_str()
-                                               , signalData.signature.c_str()
-                                               , signalData.paramNames.c_str()
-                                               , signalData.flags.toSdBusSignalFlags() ));
-    }
+    return it != vtable.methods.end() && it->name == methodName ? &*it : nullptr;
 }
 
-void Object::registerPropertiesToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
+const Object::VTable::PropertyItem* Object::findProperty(const VTable& vtable, const std::string& propertyName)
 {
-    for (const auto& item : interfaceData.properties)
+    auto it = std::lower_bound(vtable.properties.begin(), vtable.properties.end(), propertyName, [](const auto& propertyItem, const auto& propertyName)
     {
-        const auto& propertyName = item.first;
-        const auto& propertyData = item.second;
+        return propertyItem.name < propertyName;
+    });
 
-        if (!propertyData.setCallback)
-            vtable.push_back(createVTablePropertyItem( propertyName.c_str()
-                                                     , propertyData.signature.c_str()
-                                                     , &Object::sdbus_property_get_callback
-                                                     , propertyData.flags.toSdBusPropertyFlags() ));
-        else
-            vtable.push_back(createVTableWritablePropertyItem( propertyName.c_str()
-                                                             , propertyData.signature.c_str()
-                                                             , &Object::sdbus_property_get_callback
-                                                             , &Object::sdbus_property_set_callback
-                                                             , propertyData.flags.toSdBusWritablePropertyFlags() ));
-    }
-}
-
-void Object::activateInterfaceVTable( const std::string& interfaceName
-                                    , InterfaceData& interfaceData
-                                    , const std::vector<sd_bus_vtable>& vtable )
-{
-    interfaceData.slot = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], &interfaceData);
+    return it != vtable.properties.end() && it->name == propertyName ? &*it : nullptr;
 }
 
 std::string Object::paramNamesToString(const std::vector<std::string>& paramNames)
@@ -332,31 +308,19 @@ std::string Object::paramNamesToString(const std::vector<std::string>& paramName
 
 int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
 {
-    auto* interfaceData = static_cast<InterfaceData*>(userData);
-    assert(interfaceData != nullptr);
-    auto& object = interfaceData->object;
+    auto* vtable = static_cast<VTable*>(userData);
+    assert(vtable != nullptr);
+    assert(vtable->object != nullptr);
 
-    auto message = Message::Factory::create<MethodCall>(sdbusMessage, &object.connection_.getSdBusInterface());
+    auto message = Message::Factory::create<MethodCall>(sdbusMessage, &vtable->object->connection_.getSdBusInterface());
 
-    object.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
-    SCOPE_EXIT
-    {
-        object.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
-    };
+    const auto* methodItem = findMethod(*vtable, message.getMemberName());
+    assert(methodItem != nullptr);
+    assert(methodItem->callback);
 
-    auto& callback = interfaceData->methods[message.getMemberName()].callback;
-    assert(callback);
+    auto ok = invokeHandlerAndCatchErrors([&](){ methodItem->callback(std::move(message)); }, retError);
 
-    try
-    {
-        callback(message);
-    }
-    catch (const Error& e)
-    {
-        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
-    }
-
-    return 1;
+    return ok ? 1 : -1;
 }
 
 int Object::sdbus_property_get_callback( sd_bus */*bus*/
@@ -367,30 +331,25 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/
                                        , void *userData
                                        , sd_bus_error *retError )
 {
-    auto* interfaceData = static_cast<InterfaceData*>(userData);
-    assert(interfaceData != nullptr);
-    auto& object = interfaceData->object;
+    auto* vtable = static_cast<VTable*>(userData);
+    assert(vtable != nullptr);
+    assert(vtable->object != nullptr);
 
-    auto& callback = interfaceData->properties[property].getCallback;
-    // Getter can be empty - the case of "write-only" property
-    if (!callback)
+    const auto* propertyItem = findProperty(*vtable, property);
+    assert(propertyItem != nullptr);
+
+    // Getter may be empty - the case of "write-only" property
+    if (!propertyItem->getCallback)
     {
         sd_bus_error_set(retError, "org.freedesktop.DBus.Error.Failed", "Cannot read property as it is write-only");
         return 1;
     }
 
-    auto reply = Message::Factory::create<PropertyGetReply>(sdbusReply, &object.connection_.getSdBusInterface());
+    auto reply = Message::Factory::create<PropertyGetReply>(sdbusReply, &vtable->object->connection_.getSdBusInterface());
 
-    try
-    {
-        callback(reply);
-    }
-    catch (const Error& e)
-    {
-        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
-    }
+    auto ok = invokeHandlerAndCatchErrors([&](){ propertyItem->getCallback(reply); }, retError);
 
-    return 1;
+    return ok ? 1 : -1;
 }
 
 int Object::sdbus_property_set_callback( sd_bus */*bus*/
@@ -401,31 +360,19 @@ int Object::sdbus_property_set_callback( sd_bus */*bus*/
                                        , void *userData
                                        , sd_bus_error *retError )
 {
-    auto* interfaceData = static_cast<InterfaceData*>(userData);
-    assert(interfaceData != nullptr);
-    auto& object = interfaceData->object;
+    auto* vtable = static_cast<VTable*>(userData);
+    assert(vtable != nullptr);
+    assert(vtable->object != nullptr);
 
-    auto& callback = interfaceData->properties[property].setCallback;
-    assert(callback);
+    const auto* propertyItem = findProperty(*vtable, property);
+    assert(propertyItem != nullptr);
+    assert(propertyItem->setCallback);
 
-    auto value = Message::Factory::create<PropertySetCall>(sdbusValue, &object.connection_.getSdBusInterface());
+    auto value = Message::Factory::create<PropertySetCall>(sdbusValue, &vtable->object->connection_.getSdBusInterface());
 
-    object.m_CurrentlyProcessedMessage.store(&value, std::memory_order_relaxed);
-    SCOPE_EXIT
-    {
-        object.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
-    };
+    auto ok = invokeHandlerAndCatchErrors([&](){ propertyItem->setCallback(std::move(value)); }, retError);
 
-    try
-    {
-        callback(value);
-    }
-    catch (const Error& e)
-    {
-        sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
-    }
-
-    return 1;
+    return ok ? 1 : -1;
 }
 
 }

src/Object.h

@@ -27,16 +27,17 @@
 #ifndef SDBUS_CXX_INTERNAL_OBJECT_H_
 #define SDBUS_CXX_INTERNAL_OBJECT_H_
 
-#include <sdbus-c++/IObject.h>
+#include "sdbus-c++/IObject.h"
+
 #include "IConnection.h"
-#include <systemd/sd-bus.h>
-#include <string>
-#include <map>
-#include <vector>
-#include <functional>
-#include <memory>
-#include <atomic>
+
 #include <cassert>
+#include <functional>
+#include <list>
+#include <memory>
+#include <string>
+#include SDBUS_HEADER
+#include <vector>
 
 namespace sdbus::internal {
 
@@ -46,46 +47,8 @@ namespace sdbus::internal {
     public:
         Object(sdbus::internal::IConnection& connection, std::string objectPath);
 
-        void registerMethod( const std::string& interfaceName
-                           , std::string methodName
-                           , std::string inputSignature
-                           , std::string outputSignature
-                           , method_callback methodCallback
-                           , Flags flags ) override;
-        void registerMethod( const std::string& interfaceName
-                           , std::string methodName
-                           , std::string inputSignature
-                           , const std::vector<std::string>& inputNames
-                           , std::string outputSignature
-                           , const std::vector<std::string>& outputNames
-                           , method_callback methodCallback
-                           , Flags flags ) override;
-
-        void registerSignal( const std::string& interfaceName
-                           , 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
-                             , std::string propertyName
-                             , std::string signature
-                             , property_get_callback getCallback
-                             , Flags flags ) override;
-        void registerProperty( const std::string& interfaceName
-                             , std::string propertyName
-                             , std::string signature
-                             , property_get_callback getCallback
-                             , property_set_callback setCallback
-                             , Flags flags ) override;
-
-        void setInterfaceFlags(const std::string& interfaceName, Flags flags) override;
-
-        void finishRegistration() override;
+        void addVTable(std::string interfaceName, std::vector<VTableItem> vtable) override;
+        Slot addVTable(std::string interfaceName, std::vector<VTableItem> vtable, return_slot_t) override;
         void unregister() override;
 
         sdbus::Signal createSignal(const std::string& interfaceName, const std::string& signalName) override;
@@ -99,62 +62,81 @@ namespace sdbus::internal {
 
         void addObjectManager() override;
         void removeObjectManager() override;
-        bool hasObjectManager() const override;
+        [[nodiscard]] bool hasObjectManager() const override;
 
-        sdbus::IConnection& getConnection() const override;
-        const std::string& getObjectPath() const override;
-        const Message* getCurrentlyProcessedMessage() const override;
+        [[nodiscard]] sdbus::IConnection& getConnection() const override;
+        [[nodiscard]] const std::string& getObjectPath() const override;
+        [[nodiscard]] Message getCurrentlyProcessedMessage() const override;
 
     private:
-        using InterfaceName = std::string;
-        struct InterfaceData
+        // A vtable record comprising methods, signals, properties, flags.
+        // Once created, it cannot be modified. Only new vtables records can be added.
+        // An interface can have any number of vtables attached to it, not only one.
+        struct VTable
         {
-            InterfaceData(Object& object) : object(object) {}
+            std::string interfaceName;
+            Flags interfaceFlags;
 
-            using MethodName = std::string;
-            struct MethodData
+            struct MethodItem
             {
-                const std::string inputArgs;
-                const std::string outputArgs;
-                const std::string paramNames;
+                std::string name;
+                std::string inputArgs;
+                std::string outputArgs;
+                std::string paramNames;
                 method_callback callback;
                 Flags flags;
             };
-            std::map<MethodName, MethodData> methods;
-            using SignalName = std::string;
-            struct SignalData
+            // Array of method records sorted by method name
+            std::vector<MethodItem> methods;
+
+            struct SignalItem
             {
-                const std::string signature;
-                const std::string paramNames;
+                std::string name;
+                std::string signature;
+                std::string paramNames;
                 Flags flags;
             };
-            std::map<SignalName, SignalData> signals;
-            using PropertyName = std::string;
-            struct PropertyData
+            // Array of signal records sorted by signal name
+            std::vector<SignalItem> signals;
+
+            struct PropertyItem
             {
-                const std::string signature;
+                std::string name;
+                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;
-            Object& object;
+            // Array of signal records sorted by signal name
+            std::vector<PropertyItem> properties;
+
+            // VTable structure in format required by sd-bus API
+            std::vector<sd_bus_vtable> sdbusVTable;
+
+            // Back-reference to the owning object from sd-bus callback handlers
+            Object* object{};
 
             // This is intentionally the last member, because it must be destructed first,
             // releasing callbacks above before the callbacks themselves are destructed.
             Slot slot;
         };
 
-        InterfaceData& getInterface(const std::string& interfaceName);
-        static const std::vector<sd_bus_vtable>& createInterfaceVTable(InterfaceData& interfaceData);
-        static void registerMethodsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable);
-        static void registerSignalsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable);
-        static void registerPropertiesToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable);
-        void activateInterfaceVTable( const std::string& interfaceName
-                                    , InterfaceData& interfaceData
-                                    , const std::vector<sd_bus_vtable>& vtable );
+        VTable createInternalVTable(std::string interfaceName, std::vector<VTableItem> vtable);
+        void writeInterfaceFlagsToVTable(InterfaceFlagsVTableItem flags, VTable& vtable);
+        void writeMethodRecordToVTable(MethodVTableItem method, VTable& vtable);
+        void writeSignalRecordToVTable(SignalVTableItem signal, VTable& vtable);
+        void writePropertyRecordToVTable(PropertyVTableItem property, VTable& vtable);
+
+        std::vector<sd_bus_vtable> createInternalSdBusVTable(const VTable& vtable);
+        static void startSdBusVTable(const Flags& interfaceFlags, std::vector<sd_bus_vtable>& vtable);
+        static void writeMethodRecordToSdBusVTable(const VTable::MethodItem& method, std::vector<sd_bus_vtable>& vtable);
+        static void writeSignalRecordToSdBusVTable(const VTable::SignalItem& signal, std::vector<sd_bus_vtable>& vtable);
+        static void writePropertyRecordToSdBusVTable(const VTable::PropertyItem& property, std::vector<sd_bus_vtable>& vtable);
+        static void finalizeSdBusVTable(std::vector<sd_bus_vtable>& vtable);
+
+        static const VTable::MethodItem* findMethod(const VTable& vtable, const std::string& methodName);
+        static const VTable::PropertyItem* findProperty(const VTable& vtable, const std::string& propertyName);
+
         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);
@@ -176,9 +158,8 @@ namespace sdbus::internal {
     private:
         sdbus::internal::IConnection& connection_;
         std::string objectPath_;
-        std::map<InterfaceName, InterfaceData> interfaces_;
+        std::vector<Slot> vtables_;
         Slot objectManagerSlot_;
-        std::atomic<const Message*> m_CurrentlyProcessedMessage{nullptr};
     };
 
 }

src/Proxy.cpp

@@ -25,16 +25,18 @@
  */
 
 #include "Proxy.h"
+
+#include "sdbus-c++/Error.h"
+#include "sdbus-c++/IConnection.h"
+#include "sdbus-c++/Message.h"
+
 #include "IConnection.h"
 #include "MessageUtils.h"
-#include "Utils.h"
-#include "sdbus-c++/Message.h"
-#include "sdbus-c++/IConnection.h"
-#include "sdbus-c++/Error.h"
 #include "ScopeGuard.h"
-#include <systemd/sd-bus.h>
+#include "Utils.h"
+
 #include <cassert>
-#include <chrono>
+#include SDBUS_HEADER
 #include <utility>
 
 namespace sdbus::internal {
@@ -66,6 +68,21 @@ Proxy::Proxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
     connection_->enterEventLoopAsync();
 }
 
+Proxy::Proxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
+            , std::string destination
+            , std::string objectPath
+            , dont_run_event_loop_thread_t )
+    : connection_(std::move(connection))
+    , destination_(std::move(destination))
+    , objectPath_(std::move(objectPath))
+{
+    SDBUS_CHECK_SERVICE_NAME(destination_);
+    SDBUS_CHECK_OBJECT_PATH(objectPath_);
+
+    // Even though the connection is ours only, we don't start an event loop thread.
+    // This proxy is meant to be created, used for simple synchronous D-Bus call(s) and then dismissed.
+}
+
 MethodCall Proxy::createMethodCall(const std::string& interfaceName, const std::string& methodName)
 {
     return connection_->createMethodCall(destination_, objectPath_, interfaceName, methodName);
@@ -73,148 +90,84 @@ MethodCall Proxy::createMethodCall(const std::string& interfaceName, const std::
 
 MethodReply Proxy::callMethod(const MethodCall& message, uint64_t timeout)
 {
-    // Sending method call synchronously is the only operation that blocks, waiting for the method
-    // reply message among the incoming messages on the sd-bus connection socket. But typically there
-    // already is somebody that generally handles incoming D-Bus messages -- the connection event loop
-    // running typically in its own thread. We have to avoid polling on socket from several threads.
-    // So we have to branch here: either we are within the context of the event loop thread, then we
-    // can send the message simply via sd_bus_call, which blocks. Or we are in another thread, then
-    // we can perform the send operation of the method call message from here (because that is thread-
-    // safe like other sd-bus API accesses), but the incoming reply we have to get through the event
-    // loop thread, because this is 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);
+    return connection_->callMethod(message, timeout);
 }
 
-PendingAsyncCall Proxy::callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout)
+PendingAsyncCall Proxy::callMethodAsync(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 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);
+    callData->slot = connection_->callMethod(message, callback, callData.get(), timeout);
 
-    auto slotPtr = callData->slot.get();
-    pendingAsyncCalls_.addCall(slotPtr, std::move(callData));
+    pendingAsyncCalls_.addCall(std::move(callData));
 
+    // TODO: Instead of PendingAsyncCall consider using Slot implementation for simplicity and consistency
     return {weakData};
 }
 
-MethodReply Proxy::sendMethodCallMessageAndWaitForReply(const MethodCall& message, uint64_t timeout)
+std::future<MethodReply> Proxy::callMethodAsync(const MethodCall& message, with_future_t)
 {
-    /*thread_local*/ SyncCallReplyData syncCallReplyData;
+    return Proxy::callMethodAsync(message, {}, with_future);
+}
 
-    async_reply_handler asyncReplyCallback = [&syncCallReplyData](MethodReply& reply, const Error* error)
+std::future<MethodReply> Proxy::callMethodAsync(const MethodCall& message, uint64_t timeout, with_future_t)
+{
+    auto promise = std::make_shared<std::promise<MethodReply>>();
+    auto future = promise->get_future();
+
+    async_reply_handler asyncReplyCallback = [promise = std::move(promise)](MethodReply reply, std::optional<Error> error) noexcept
     {
-        syncCallReplyData.sendMethodReplyToWaitingThread(reply, error);
+        if (!error)
+            promise->set_value(std::move(reply));
+        else
+            promise->set_exception(std::make_exception_ptr(*std::move(error)));
     };
-    auto callback = (void*)&Proxy::sdbus_async_reply_handler;
-    AsyncCalls::CallData callData{*this, std::move(asyncReplyCallback), {}};
 
-    message.send(callback, &callData, timeout, floating_slot);
+    (void)Proxy::callMethodAsync(message, std::move(asyncReplyCallback), timeout);
 
-    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_);
+    return future;
 }
 
 void Proxy::registerSignalHandler( const std::string& interfaceName
                                  , const std::string& signalName
                                  , signal_handler signalHandler )
+{
+    auto slot = Proxy::registerSignalHandler(interfaceName, signalName, std::move(signalHandler), return_slot);
+
+    floatingSignalSlots_.push_back(std::move(slot));
+}
+
+Slot Proxy::registerSignalHandler( const std::string& interfaceName
+                                 , const std::string& signalName
+                                 , signal_handler signalHandler
+                                 , return_slot_t )
 {
     SDBUS_CHECK_INTERFACE_NAME(interfaceName);
     SDBUS_CHECK_MEMBER_NAME(signalName);
     SDBUS_THROW_ERROR_IF(!signalHandler, "Invalid signal handler provided", EINVAL);
 
-    auto& interface = interfaces_[interfaceName];
+    auto signalInfo = std::make_unique<SignalInfo>(SignalInfo{std::move(signalHandler), *this, {}});
 
-    auto signalData = std::make_unique<InterfaceData::SignalData>(*this, std::move(signalHandler), nullptr);
-    auto insertionResult = interface.signals_.emplace(signalName, std::move(signalData));
+    signalInfo->slot = connection_->registerSignalHandler( destination_
+                                                         , objectPath_
+                                                         , interfaceName
+                                                         , signalName
+                                                         , &Proxy::sdbus_signal_handler
+                                                         , signalInfo.get() );
 
-    auto inserted = insertionResult.second;
-    SDBUS_THROW_ERROR_IF(!inserted, "Failed to register signal handler: handler already exists", EINVAL);
-}
-
-void Proxy::unregisterSignalHandler( const std::string& interfaceName
-                                   , const std::string& signalName )
-{
-    auto it = interfaces_.find(interfaceName);
-
-    if (it != interfaces_.end())
-        it->second.signals_.erase(signalName);
-}
-
-void Proxy::finishRegistration()
-{
-    registerSignalHandlers(*connection_);
-}
-
-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* signalData = signalItem.second.get();
-            signalData->slot = connection.registerSignalHandler( destination_
-                                                               , objectPath_
-                                                               , interfaceName
-                                                               , signalName
-                                                               , &Proxy::sdbus_signal_handler
-                                                               , signalData);
-        }
-    }
+    return {signalInfo.release(), [](void *ptr){ delete static_cast<SignalInfo*>(ptr); }};
 }
 
 void Proxy::unregister()
 {
     pendingAsyncCalls_.clear();
-    interfaces_.clear();
+    floatingSignalSlots_.clear();
 }
 
 sdbus::IConnection& Proxy::getConnection() const
@@ -227,82 +180,57 @@ const std::string& Proxy::getObjectPath() const
     return objectPath_;
 }
 
-const Message* Proxy::getCurrentlyProcessedMessage() const
+Message Proxy::getCurrentlyProcessedMessage() const
 {
-    return m_CurrentlyProcessedMessage.load(std::memory_order_relaxed);
+    return connection_->getCurrentlyProcessedMessage();
 }
 
-int Proxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
+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);
+        proxy.pendingAsyncCalls_.removeCall(asyncCallData);
     };
 
     auto message = Message::Factory::create<MethodReply>(sdbusMessage, &proxy.connection_->getSdBusInterface());
 
-    proxy.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
-    SCOPE_EXIT
-    {
-        proxy.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
-    };
-
-    try
+    auto ok = invokeHandlerAndCatchErrors([&]
     {
         const auto* error = sd_bus_message_get_error(sdbusMessage);
         if (error == nullptr)
         {
-            asyncCallData->callback(message, nullptr);
+            asyncCallData->callback(std::move(message), {});
         }
         else
         {
             Error exception(error->name, error->message);
-            asyncCallData->callback(message, &exception);
+            asyncCallData->callback(std::move(message), std::move(exception));
         }
-    }
-    catch (const Error&)
-    {
-        // Intentionally left blank -- sdbus-c++ exceptions shall not bubble up to the underlying C sd-bus library
-    }
+    }, retError);
 
-    return 0;
+    return ok ? 0 : -1;
 }
 
-int Proxy::sdbus_signal_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error */*retError*/)
+int Proxy::sdbus_signal_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
 {
-    auto* signalData = static_cast<InterfaceData::SignalData*>(userData);
-    assert(signalData != nullptr);
-    assert(signalData->callback);
+    auto* signalInfo = static_cast<SignalInfo*>(userData);
+    assert(signalInfo != nullptr);
+    assert(signalInfo->callback);
 
-    auto message = Message::Factory::create<Signal>(sdbusMessage, &signalData->proxy.connection_->getSdBusInterface());
+    // TODO: Hide Message factory invocation under Connection API (tell, don't ask principle), then we can remove getSdBusInterface()
+    auto message = Message::Factory::create<Signal>(sdbusMessage, &signalInfo->proxy.connection_->getSdBusInterface());
 
-    signalData->proxy.m_CurrentlyProcessedMessage.store(&message, std::memory_order_relaxed);
-    SCOPE_EXIT
-    {
-        signalData->proxy.m_CurrentlyProcessedMessage.store(nullptr, std::memory_order_relaxed);
-    };
+    auto ok = invokeHandlerAndCatchErrors([&](){ signalInfo->callback(std::move(message)); }, retError);
 
-    try
-    {
-        signalData->callback(message);
-    }
-    catch (const Error&)
-    {
-        // Intentionally left blank -- sdbus-c++ exceptions shall not bubble up to the underlying C sd-bus library
-    }
-
-    return 0;
+    return ok ? 0 : -1;
 }
 
 }
@@ -319,7 +247,7 @@ 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());
+        callData->proxy.pendingAsyncCalls_.removeCall(callData);
 
         // 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
@@ -363,10 +291,26 @@ std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<IConnection>&& conne
                                                    , std::move(objectPath) );
 }
 
+std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<IConnection>&& connection
+                                          , std::string destination
+                                          , std::string objectPath
+                                          , dont_run_event_loop_thread_t )
+{
+    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)
+                                                   , dont_run_event_loop_thread );
+}
+
 std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
                                           , std::string objectPath )
 {
-    auto connection = sdbus::createConnection();
+    auto connection = sdbus::createBusConnection();
 
     auto sdbusConnection = std::unique_ptr<sdbus::internal::IConnection>(dynamic_cast<sdbus::internal::IConnection*>(connection.release()));
     assert(sdbusConnection != nullptr);
@@ -376,4 +320,19 @@ std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
                                                    , std::move(objectPath) );
 }
 
+std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
+                                          , std::string objectPath
+                                          , dont_run_event_loop_thread_t )
+{
+    auto connection = sdbus::createBusConnection();
+
+    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)
+                                                   , dont_run_event_loop_thread );
+}
+
 }

src/Proxy.h

@@ -27,16 +27,16 @@
 #ifndef SDBUS_CXX_INTERNAL_PROXY_H_
 #define SDBUS_CXX_INTERNAL_PROXY_H_
 
-#include <sdbus-c++/IProxy.h>
+#include "sdbus-c++/IProxy.h"
+
 #include "IConnection.h"
-#include <systemd/sd-bus.h>
-#include <string>
+
+#include <deque>
 #include <memory>
-#include <map>
-#include <unordered_map>
 #include <mutex>
-#include <atomic>
-#include <condition_variable>
+#include <string>
+#include SDBUS_HEADER
+#include <vector>
 
 namespace sdbus::internal {
 
@@ -50,43 +50,33 @@ namespace sdbus::internal {
         Proxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
              , std::string destination
              , std::string objectPath );
+        Proxy( std::unique_ptr<sdbus::internal::IConnection>&& connection
+             , std::string destination
+             , std::string objectPath
+             , dont_run_event_loop_thread_t );
 
         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;
+        PendingAsyncCall callMethodAsync(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout) override;
+        std::future<MethodReply> callMethodAsync(const MethodCall& message, with_future_t) override;
+        std::future<MethodReply> callMethodAsync(const MethodCall& message, uint64_t timeout, with_future_t) override;
 
         void registerSignalHandler( const std::string& interfaceName
                                   , const std::string& signalName
                                   , signal_handler signalHandler ) override;
-        void unregisterSignalHandler( const std::string& interfaceName
-                                    , const std::string& signalName ) override;
-
-        void finishRegistration() override;
+        Slot registerSignalHandler( const std::string& interfaceName
+                                  , const std::string& signalName
+                                  , signal_handler signalHandler
+                                  , return_slot_t ) override;
         void unregister() override;
 
-        sdbus::IConnection& getConnection() const override;
-        const std::string& getObjectPath() const override;
-        const Message* getCurrentlyProcessedMessage() const override;
+        [[nodiscard]] sdbus::IConnection& getConnection() const override;
+        [[nodiscard]] const std::string& getObjectPath() const override;
+        [[nodiscard]] Message getCurrentlyProcessedMessage() 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);
+        static int sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
 
     private:
         friend PendingAsyncCall;
@@ -97,28 +87,14 @@ namespace sdbus::internal {
         std::string destination_;
         std::string objectPath_;
 
-        using InterfaceName = std::string;
-        struct InterfaceData
+        std::vector<Slot> floatingSignalSlots_;
+
+        struct SignalInfo
         {
-            using SignalName = std::string;
-            struct SignalData
-            {
-                SignalData(Proxy& proxy, signal_handler callback, Slot slot)
-                    : proxy(proxy)
-                    , callback(std::move(callback))
-                    , slot(std::move(slot))
-                {}
-                Proxy& proxy;
-                signal_handler callback;
-                // slot must be listed after callback to ensure that slot is destructed first.
-                // Destructing the slot will sd_bus_slot_unref() the callback.
-                // Only after sd_bus_slot_unref(), we can safely delete the callback. The bus mutex (SdBus::sdbusMutex_)
-                // ensures that sd_bus_slot_unref() and the callback execute sequentially.
-                Slot slot;
-            };
-            std::map<SignalName, std::unique_ptr<SignalData>> signals_;
+            signal_handler callback;
+            Proxy& proxy;
+            Slot slot;
         };
-        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
@@ -131,7 +107,8 @@ namespace sdbus::internal {
             {
                 Proxy& proxy;
                 async_reply_handler callback;
-                Slot slot;
+                Slot slot{};
+                bool finished{false};
             };
 
             ~AsyncCalls()
@@ -139,18 +116,20 @@ namespace sdbus::internal {
                 clear();
             }
 
-            bool addCall(void* slot, std::shared_ptr<CallData> asyncCallData)
+            void addCall(std::shared_ptr<CallData> asyncCallData)
             {
                 std::lock_guard lock(mutex_);
-                return calls_.emplace(slot, std::move(asyncCallData)).second;
+                if (!asyncCallData->finished) // The call may have finished in the meantime
+                    calls_.emplace_back(std::move(asyncCallData));
             }
 
-            void removeCall(void* slot)
+            void removeCall(CallData* data)
             {
                 std::unique_lock lock(mutex_);
-                if (auto it = calls_.find(slot); it != calls_.end())
+                data->finished = true;
+                if (auto it = std::find_if(calls_.begin(), calls_.end(), [data](auto const& entry){ return entry.get() == data; }); it != calls_.end())
                 {
-                    auto callData = std::move(it->second);
+                    auto callData = std::move(*it);
                     calls_.erase(it);
                     lock.unlock();
 
@@ -176,10 +155,8 @@ namespace sdbus::internal {
 
         private:
             std::mutex mutex_;
-            std::unordered_map<void*, std::shared_ptr<CallData>> calls_;
+            std::deque<std::shared_ptr<CallData>> calls_;
         } pendingAsyncCalls_;
-
-        std::atomic<const Message*> m_CurrentlyProcessedMessage{nullptr};
     };
 
 }

src/ScopeGuard.h

@@ -27,6 +27,7 @@
 #ifndef SDBUS_CPP_INTERNAL_SCOPEGUARD_H_
 #define SDBUS_CPP_INTERNAL_SCOPEGUARD_H_
 
+#include <exception>
 #include <utility>
 
 // Straightforward, modern, easy-to-use RAII utility to perform work on scope exit in an exception-safe manner.
@@ -55,78 +56,115 @@
 //     return; // exiting scope normally
 // }
 
-#define SCOPE_EXIT                                          \
-    auto ANONYMOUS_VARIABLE(SCOPE_EXIT_STATE)               \
-    = ::skybase::utils::detail::ScopeGuardOnExit() + [&]()  \
+#define SCOPE_EXIT                                                \
+    auto ANONYMOUS_VARIABLE(SCOPE_EXIT_STATE)                     \
+        = ::sdbus::internal::ScopeGuardOnExitTag{} + [&]()        \
+    /**/
+#define SCOPE_EXIT_NAMED(NAME)                                    \
+    auto NAME                                                     \
+        = ::sdbus::internal::ScopeGuardOnExitTag{} + [&]()        \
+    /**/
+#define SCOPE_EXIT_SUCCESS                                        \
+    auto ANONYMOUS_VARIABLE(SCOPE_EXIT_STATE)                     \
+        = ::sdbus::internal::ScopeGuardOnExitSuccessTag{} + [&]() \
+    /**/
+#define SCOPE_EXIT_SUCCESS_NAMED(NAME)                            \
+    auto NAME                                                     \
+        = ::sdbus::internal::ScopeGuardOnExitSuccessTag{} + [&]() \
+    /**/
+#define SCOPE_EXIT_FAILURE                                        \
+    auto ANONYMOUS_VARIABLE(SCOPE_EXIT_STATE)                     \
+        = ::sdbus::internal::ScopeGuardOnExitFailureTag{} + [&]() \
+    /**/
+#define SCOPE_EXIT_FAILURE_NAMED(NAME)                            \
+    auto NAME                                                     \
+        = ::sdbus::internal::ScopeGuardOnExitFailureTag{} + [&]() \
     /**/
 
-#define SCOPE_EXIT_NAMED(NAME)                              \
-    auto NAME                                               \
-    = ::skybase::utils::detail::ScopeGuardOnExit() + [&]()  \
-    /**/
+namespace sdbus::internal {
 
-namespace skybase {
-namespace utils {
+    struct ScopeGuardOnExitTag
+    {
+        static bool holds(int /*originalExceptions*/)
+        {
+            return true; // Always holds
+        }
+    };
+    struct ScopeGuardOnExitSuccessTag
+    {
+        static bool holds(int originalExceptions)
+        {
+            return originalExceptions == std::uncaught_exceptions(); // Only holds when no exception occurred within the scope
+        }
+    };
+    struct ScopeGuardOnExitFailureTag
+    {
+        static bool holds(int originalExceptions)
+        {
+            return originalExceptions != std::uncaught_exceptions(); // Only holds when an exception occurred within the scope
+        }
+    };
 
-    template <class _Fun>
+    template <class _Fun, typename _Tag>
     class ScopeGuard
     {
-        _Fun fnc_;
-        bool active_;
-
     public:
-        ScopeGuard(_Fun f)
-            : fnc_(std::move(f))
-            , active_(true)
+        ScopeGuard(_Fun f) : fnc_(std::move(f))
         {
         }
-        ~ScopeGuard()
+
+        ScopeGuard() = delete;
+        ScopeGuard(const ScopeGuard&) = delete;
+        ScopeGuard& operator=(const ScopeGuard&) = delete;
+        ScopeGuard(ScopeGuard&& rhs) : fnc_(std::move(rhs.fnc_)), active_(rhs.active_), exceptions_(rhs.exceptions_)
         {
-            if (active_)
-                fnc_();
+            rhs.dismiss();
         }
+
         void dismiss()
         {
             active_ = false;
         }
-        ScopeGuard() = delete;
-        ScopeGuard(const ScopeGuard&) = delete;
-        ScopeGuard& operator=(const ScopeGuard&) = delete;
-        ScopeGuard(ScopeGuard&& rhs)
-            : fnc_(std::move(rhs.fnc_))
-            , active_(rhs.active_)
+
+        ~ScopeGuard()
         {
-            rhs.dismiss();
+            if (active_ && _Tag::holds(exceptions_))
+                fnc_();
         }
+
+    private:
+        _Fun fnc_;
+        int exceptions_{std::uncaught_exceptions()};
+        bool active_{true};
     };
 
-    namespace detail
+    template <typename _Fun>
+    ScopeGuard<_Fun, ScopeGuardOnExitTag> operator+(ScopeGuardOnExitTag, _Fun&& fnc)
     {
-        enum class ScopeGuardOnExit
-        {
-        };
-
-        // Helper function to auto-deduce type of the callable entity
-        template <typename _Fun>
-        ScopeGuard<_Fun> operator+(ScopeGuardOnExit, _Fun&& fnc)
-        {
-            return ScopeGuard<_Fun>(std::forward<_Fun>(fnc));
-        }
+        return ScopeGuard<_Fun, ScopeGuardOnExitTag>(std::forward<_Fun>(fnc));
     }
 
-}}
+    template <typename _Fun>
+    ScopeGuard<_Fun, ScopeGuardOnExitSuccessTag> operator+(ScopeGuardOnExitSuccessTag, _Fun&& fnc)
+    {
+        return ScopeGuard<_Fun, ScopeGuardOnExitSuccessTag>(std::forward<_Fun>(fnc));
+    }
+
+    template <typename _Fun>
+    ScopeGuard<_Fun, ScopeGuardOnExitFailureTag> operator+(ScopeGuardOnExitFailureTag, _Fun&& fnc)
+    {
+        return ScopeGuard<_Fun, ScopeGuardOnExitFailureTag>(std::forward<_Fun>(fnc));
+    }
+
+}
 
 #define CONCATENATE_IMPL(s1, s2) s1##s2
 #define CONCATENATE(s1, s2) CONCATENATE_IMPL(s1, s2)
 
 #ifdef __COUNTER__
-#define ANONYMOUS_VARIABLE(str)                 \
-    CONCATENATE(str, __COUNTER__)               \
-    /**/
+#define ANONYMOUS_VARIABLE(str) CONCATENATE(str, __COUNTER__)
 #else
-#define ANONYMOUS_VARIABLE(str)                 \
-    CONCATENATE(str, __LINE__)                  \
-    /**/
+#define ANONYMOUS_VARIABLE(str) CONCATENATE(str, __LINE__)
 #endif
 
 #endif /* SDBUS_CPP_INTERNAL_SCOPEGUARD_H_ */

src/SdBus.cpp

@@ -48,7 +48,16 @@ int SdBus::sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie)
 {
     std::lock_guard lock(sdbusMutex_);
 
-    return ::sd_bus_send(bus, m, cookie);
+    auto r = ::sd_bus_send(bus, m, cookie);
+    if (r < 0)
+        return r;
+
+    // Make sure long messages are not only stored in outgoing queues but also really sent out
+    // TODO: This is a workaround. We should not block here until everything is physically sent out.
+    //   Refactor: if sd_bus_get_n_queued_write() > 0 then wake up event loop through event fd
+    ::sd_bus_flush(bus != nullptr ? bus : ::sd_bus_message_get_bus(m));
+
+    return r;
 }
 
 int SdBus::sd_bus_call(sd_bus *bus, sd_bus_message *m, uint64_t usec, sd_bus_error *ret_error, sd_bus_message **reply)
@@ -62,7 +71,16 @@ int SdBus::sd_bus_call_async(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m,
 {
     std::lock_guard lock(sdbusMutex_);
 
-    return ::sd_bus_call_async(bus, slot, m, callback, userdata, usec);
+    auto r = ::sd_bus_call_async(bus, slot, m, callback, userdata, usec);
+    if (r < 0)
+      return r;
+
+    // Make sure long messages are not only stored in outgoing queues but also really sent out
+    // TODO: This is a workaround. We should not block here until everything is physically sent out.
+    //   Refactor: if sd_bus_get_n_queued_write() > 0 then wake up event loop through event fd
+    ::sd_bus_flush(bus != nullptr ? bus : ::sd_bus_message_get_bus(m));
+
+    return r;
 }
 
 int SdBus::sd_bus_message_new(sd_bus *bus, sd_bus_message **m, uint8_t type)
@@ -180,26 +198,98 @@ int SdBus::sd_bus_open_user_with_address(sd_bus **ret, const char* address)
 {
     sd_bus* bus = nullptr;
 
-    int r = sd_bus_new(&bus);
+    int r = ::sd_bus_new(&bus);
     if (r < 0)
         return r;
 
-    r = sd_bus_set_address(bus, address);
+    r = ::sd_bus_set_address(bus, address);
     if (r < 0)
         return r;
 
-    r = sd_bus_set_bus_client(bus, true);
+    r = ::sd_bus_set_bus_client(bus, true);
     if (r < 0)
         return r;
 
     // Copying behavior from
     // https://github.com/systemd/systemd/blob/fee6441601c979165ebcbb35472036439f8dad5f/src/libsystemd/sd-bus/sd-bus.c#L1381
     // Here, we make the bus as trusted
-    r = sd_bus_set_trusted(bus, true);
+    r = ::sd_bus_set_trusted(bus, true);
     if (r < 0)
         return r;
 
-    r = sd_bus_start(bus);
+    r = ::sd_bus_start(bus);
+    if (r < 0)
+        return r;
+
+    *ret = bus;
+
+    return 0;
+}
+
+int SdBus::sd_bus_open_direct(sd_bus **ret, const char* address)
+{
+    sd_bus* bus = nullptr;
+
+    int r = ::sd_bus_new(&bus);
+    if (r < 0)
+        return r;
+
+    r = ::sd_bus_set_address(bus, address);
+    if (r < 0)
+        return r;
+
+    r = ::sd_bus_start(bus);
+    if (r < 0)
+        return r;
+
+    *ret = bus;
+
+    return 0;
+}
+
+int SdBus::sd_bus_open_direct(sd_bus **ret, int fd)
+{
+    sd_bus* bus = nullptr;
+
+    int r = ::sd_bus_new(&bus);
+    if (r < 0)
+        return r;
+
+    r = ::sd_bus_set_fd(bus, fd, fd);
+    if (r < 0)
+        return r;
+
+    r = ::sd_bus_start(bus);
+    if (r < 0)
+        return r;
+
+    *ret = bus;
+
+    return 0;
+}
+
+int SdBus::sd_bus_open_server(sd_bus **ret, int fd)
+{
+    sd_bus* bus = nullptr;
+
+    int r = ::sd_bus_new(&bus);
+    if (r < 0)
+        return r;
+
+    r = ::sd_bus_set_fd(bus, fd, fd);
+    if (r < 0)
+        return r;
+
+    sd_id128_t id;
+    r = ::sd_id128_randomize(&id);
+    if (r < 0)
+        return r;
+
+    r = ::sd_bus_set_server(bus, true, id);
+    if (r < 0)
+        return r;
+
+    r = ::sd_bus_start(bus);
     if (r < 0)
         return r;
 
@@ -210,7 +300,14 @@ int SdBus::sd_bus_open_user_with_address(sd_bus **ret, const char* address)
 
 int SdBus::sd_bus_open_system_remote(sd_bus **ret, const char *host)
 {
+#ifndef SDBUS_basu
     return ::sd_bus_open_system_remote(ret, host);
+#else
+    (void)ret;
+    (void)host;
+    // https://git.sr.ht/~emersion/basu/commit/01d33b244eb6
+    return -EOPNOTSUPP;
+#endif
 }
 
 int SdBus::sd_bus_request_name(sd_bus *bus, const char *name, uint64_t flags)
@@ -251,7 +348,21 @@ int SdBus::sd_bus_add_match(sd_bus *bus, sd_bus_slot **slot, const char *match,
 {
     std::lock_guard lock(sdbusMutex_);
 
-    return :: sd_bus_add_match(bus, slot, match, callback, userdata);
+    return ::sd_bus_add_match(bus, slot, match, callback, userdata);
+}
+
+int SdBus::sd_bus_add_match_async(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_add_match_async(bus, slot, match, callback, install_callback, userdata);
+}
+
+int SdBus::sd_bus_match_signal(sd_bus *bus, sd_bus_slot **ret, const char *sender, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_match_signal(bus, ret, sender, path, interface, member, callback, userdata);
 }
 
 sd_bus_slot* SdBus::sd_bus_slot_unref(sd_bus_slot *slot)
@@ -278,6 +389,11 @@ int SdBus::sd_bus_process(sd_bus *bus, sd_bus_message **r)
     return ::sd_bus_process(bus, r);
 }
 
+sd_bus_message* SdBus::sd_bus_get_current_message(sd_bus *bus)
+{
+    return ::sd_bus_get_current_message(bus);
+}
+
 int SdBus::sd_bus_get_poll_data(sd_bus *bus, PollData* data)
 {
     std::lock_guard lock(sdbusMutex_);
@@ -297,6 +413,13 @@ int SdBus::sd_bus_get_poll_data(sd_bus *bus, PollData* data)
     return r;
 }
 
+int SdBus::sd_bus_get_n_queued_read(sd_bus *bus, uint64_t *ret)
+{
+    std::lock_guard lock(sdbusMutex_);
+
+    return ::sd_bus_get_n_queued_read(bus, ret);
+}
+
 int SdBus::sd_bus_flush(sd_bus *bus)
 {
     return ::sd_bus_flush(bus);

src/SdBus.h

@@ -63,20 +63,26 @@ public:
     virtual int sd_bus_open_user(sd_bus **ret) override;
     virtual int sd_bus_open_user_with_address(sd_bus **ret, const char* address) override;
     virtual int sd_bus_open_system_remote(sd_bus **ret, const char* hsot) override;
+    virtual int sd_bus_open_direct(sd_bus **ret, const char* address) override;
+    virtual int sd_bus_open_direct(sd_bus **ret, int fd) override;
+    virtual int sd_bus_open_server(sd_bus **ret, int fd) 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 int sd_bus_add_match_async(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata) override;
+    virtual int sd_bus_match_signal(sd_bus *bus, sd_bus_slot **ret, const char *sender, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata) override;
     virtual sd_bus_slot* sd_bus_slot_unref(sd_bus_slot *slot) override;
 
     virtual int sd_bus_new(sd_bus **ret) override;
     virtual int sd_bus_start(sd_bus *bus) override;
 
     virtual int sd_bus_process(sd_bus *bus, sd_bus_message **r) override;
+    virtual sd_bus_message* sd_bus_get_current_message(sd_bus *bus) override;
     virtual int sd_bus_get_poll_data(sd_bus *bus, PollData* data) override;
-
+    virtual int sd_bus_get_n_queued_read(sd_bus *bus, uint64_t *ret) override;
     virtual int sd_bus_flush(sd_bus *bus) override;
     virtual sd_bus *sd_bus_flush_close_unref(sd_bus *bus) override;
     virtual sd_bus *sd_bus_close_unref(sd_bus *bus) override;

src/Types.cpp

@@ -24,11 +24,16 @@
  * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <sdbus-c++/Types.h>
-#include <sdbus-c++/Error.h>
+#include "sdbus-c++/Types.h"
+
+#include "sdbus-c++/Error.h"
+
 #include "MessageUtils.h"
-#include <systemd/sd-bus.h>
-#include <cassert>
+
+#include <cerrno>
+#include <system_error>
+#include SDBUS_HEADER
+#include <unistd.h>
 
 namespace sdbus {
 
@@ -64,4 +69,27 @@ bool Variant::isEmpty() const
     return msg_.isEmpty();
 }
 
+void UnixFd::close() // NOLINT(readability-make-member-function-const)
+{
+    if (fd_ >= 0)
+    {
+        ::close(fd_);
+    }
 }
+
+int UnixFd::checkedDup(int fd)
+{
+    if (fd < 0)
+    {
+        return fd;
+    }
+
+    int ret = ::dup(fd); // NOLINT(android-cloexec-dup) // TODO: verify
+    if (ret < 0)
+    {
+        throw std::system_error(errno, std::generic_category(), "dup failed");
+    }
+    return ret;
+}
+
+} // namespace sdbus

src/Utils.h

@@ -28,20 +28,20 @@
 #define SDBUS_CXX_INTERNAL_UTILS_H_
 
 #include <sdbus-c++/Error.h>
-#include <systemd/sd-bus.h>
+#include SDBUS_HEADER
 
 #if LIBSYSTEMD_VERSION>=246
-#define SDBUS_CHECK_OBJECT_PATH(_PATH)                                                                                              \
-    SDBUS_THROW_ERROR_IF(!sd_bus_object_path_is_valid(_PATH.c_str()), "Invalid object path '" + _PATH + "' provided", EINVAL)       \
+#define SDBUS_CHECK_OBJECT_PATH(_PATH)                                                                                                            \
+    SDBUS_THROW_ERROR_IF(!sd_bus_object_path_is_valid(_PATH.c_str()), "Invalid object path '" + _PATH + "' provided", EINVAL)                     \
     /**/
-#define SDBUS_CHECK_INTERFACE_NAME(_NAME)                                                                                           \
-    SDBUS_THROW_ERROR_IF(!sd_bus_interface_name_is_valid(_NAME.c_str()), "Invalid interface name '" + _NAME + "' provided", EINVAL) \
+#define SDBUS_CHECK_INTERFACE_NAME(_NAME)                                                                                                         \
+    SDBUS_THROW_ERROR_IF(!sd_bus_interface_name_is_valid(_NAME.c_str()), "Invalid interface name '" + _NAME + "' provided", EINVAL)               \
     /**/
-#define SDBUS_CHECK_SERVICE_NAME(_NAME)                                                                                             \
-    SDBUS_THROW_ERROR_IF(!sd_bus_service_name_is_valid(_NAME.c_str()), "Invalid service name '" + _NAME + "' provided", EINVAL)     \
+#define SDBUS_CHECK_SERVICE_NAME(_NAME)                                                                                                           \
+    SDBUS_THROW_ERROR_IF(!_NAME.empty() && !sd_bus_service_name_is_valid(_NAME.c_str()), "Invalid service name '" + _NAME + "' provided", EINVAL) \
     /**/
-#define SDBUS_CHECK_MEMBER_NAME(_NAME)                                                                                              \
-    SDBUS_THROW_ERROR_IF(!sd_bus_member_name_is_valid(_NAME.c_str()), "Invalid member name '" + _NAME + "' provided", EINVAL)       \
+#define SDBUS_CHECK_MEMBER_NAME(_NAME)                                                                                                            \
+    SDBUS_THROW_ERROR_IF(!sd_bus_member_name_is_valid(_NAME.c_str()), "Invalid member name '" + _NAME + "' provided", EINVAL)                     \
     /**/
 #else
 #define SDBUS_CHECK_OBJECT_PATH(_PATH)
@@ -50,4 +50,49 @@
 #define SDBUS_CHECK_MEMBER_NAME(_NAME)
 #endif
 
+namespace sdbus::internal {
+
+    template <typename _Callable>
+    bool invokeHandlerAndCatchErrors(_Callable callable, sd_bus_error *retError)
+    {
+        try
+        {
+            callable();
+        }
+        catch (const Error& e)
+        {
+            sd_bus_error_set(retError, e.getName().c_str(), e.getMessage().c_str());
+            return false;
+        }
+        catch (const std::exception& e)
+        {
+            sd_bus_error_set(retError, SDBUSCPP_ERROR_NAME, e.what());
+            return false;
+        }
+        catch (...)
+        {
+            sd_bus_error_set(retError, SDBUSCPP_ERROR_NAME, "Unknown error occurred");
+            return false;
+        }
+
+        return true;
+    }
+
+    // Returns time since epoch based of POSIX CLOCK_MONOTONIC,
+    // so we use the very same clock as underlying sd-bus library.
+    [[nodiscard]] inline auto now()
+    {
+        struct timespec ts{};
+        auto r = clock_gettime(CLOCK_MONOTONIC, &ts);
+        SDBUS_THROW_ERROR_IF(r < 0, "clock_gettime failed: ", -errno);
+
+        return std::chrono::nanoseconds(ts.tv_nsec) + std::chrono::seconds(ts.tv_sec);
+    }
+
+    // Implementation of the overload pattern for variant visitation
+    template <class... Ts> struct overload : Ts... { using Ts::operator()...; };
+    template <class... Ts> overload(Ts...) -> overload<Ts...>;
+
+}
+
 #endif /* SDBUS_CXX_INTERNAL_UTILS_H_ */

src/VTableUtils.c

@@ -25,20 +25,20 @@
  */
 
 #include "VTableUtils.h"
-#include <systemd/sd-bus.h>
+#include SDBUS_HEADER
 
-sd_bus_vtable createVTableStartItem(uint64_t flags)
+sd_bus_vtable createSdBusVTableStartItem(uint64_t flags)
 {
     struct sd_bus_vtable vtableStart = SD_BUS_VTABLE_START(flags);
     return vtableStart;
 }
 
-sd_bus_vtable createVTableMethodItem( const char *member
-                                    , const char *signature
-                                    , const char *result
-                                    , const char *paramNames
-                                    , sd_bus_message_handler_t handler
-                                    , uint64_t flags )
+sd_bus_vtable createSdBusVTableMethodItem( 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
@@ -65,10 +65,10 @@ sd_bus_vtable createVTableMethodItem( const char *member
     return vtableItem;
 }
 
-sd_bus_vtable createVTableSignalItem( const char *member
-                                    , const char *signature
-                                    , const char *outnames
-                                    , uint64_t flags )
+sd_bus_vtable createSdBusVTableSignalItem( 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);
@@ -79,26 +79,26 @@ sd_bus_vtable createVTableSignalItem( const char *member
     return vtableItem;
 }
 
-sd_bus_vtable createVTablePropertyItem( const char *member
-                                      , const char *signature
-                                      , sd_bus_property_get_t getter
-                                      , uint64_t flags )
+sd_bus_vtable createSdBusVTableReadOnlyPropertyItem( const char *member
+                                                   , const char *signature
+                                                   , sd_bus_property_get_t getter
+                                                   , uint64_t flags )
 {
     struct sd_bus_vtable vtableItem = SD_BUS_PROPERTY(member, signature, getter, 0, flags);
     return vtableItem;
 }
 
-sd_bus_vtable createVTableWritablePropertyItem( const char *member
-                                              , const char *signature
-                                              , sd_bus_property_get_t getter
-                                              , sd_bus_property_set_t setter
-                                              , uint64_t flags )
+sd_bus_vtable createSdBusVTableWritablePropertyItem( const char *member
+                                                   , const char *signature
+                                                   , sd_bus_property_get_t getter
+                                                   , sd_bus_property_set_t setter
+                                                   , uint64_t flags )
 {
     struct sd_bus_vtable vtableItem = SD_BUS_WRITABLE_PROPERTY(member, signature, getter, setter, 0, flags);
     return vtableItem;
 }
 
-sd_bus_vtable createVTableEndItem()
+sd_bus_vtable createSdBusVTableEndItem()
 {
     struct sd_bus_vtable vtableEnd = SD_BUS_VTABLE_END;
     return vtableEnd;

src/VTableUtils.h

@@ -27,34 +27,34 @@
 #ifndef SDBUS_CXX_INTERNAL_VTABLEUTILS_H_
 #define SDBUS_CXX_INTERNAL_VTABLEUTILS_H_
 
-#include <systemd/sd-bus.h>
 #include <stdbool.h>
+#include SDBUS_HEADER
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-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
-                                      , sd_bus_property_get_t getter
-                                      , uint64_t flags );
-sd_bus_vtable createVTableWritablePropertyItem( const char *member
-                                              , const char *signature
-                                              , sd_bus_property_get_t getter
-                                              , sd_bus_property_set_t setter
-                                              , uint64_t flags );
-sd_bus_vtable createVTableEndItem();
+sd_bus_vtable createSdBusVTableStartItem(uint64_t flags);
+sd_bus_vtable createSdBusVTableMethodItem( const char *member
+                                         , const char *signature
+                                         , const char *result
+                                         , const char *paramNames
+                                         , sd_bus_message_handler_t handler
+                                         , uint64_t flags );
+sd_bus_vtable createSdBusVTableSignalItem( const char *member
+                                         , const char *signature
+                                         , const char *outnames
+                                         , uint64_t flags );
+sd_bus_vtable createSdBusVTableReadOnlyPropertyItem( const char *member
+                                                   , const char *signature
+                                                   , sd_bus_property_get_t getter
+                                                   , uint64_t flags );
+sd_bus_vtable createSdBusVTableWritablePropertyItem( const char *member
+                                                   , const char *signature
+                                                   , sd_bus_property_get_t getter
+                                                   , sd_bus_property_set_t setter
+                                                   , uint64_t flags );
+sd_bus_vtable createSdBusVTableEndItem();
 
 #ifdef __cplusplus
 }

tests/CMakeLists.txt

@@ -2,9 +2,6 @@
 # DOWNLOAD AND BUILD OF GOOGLETEST
 #-------------------------------
 
-set(GOOGLETEST_VERSION 1.10.0 CACHE STRING "Version of gmock to use")
-set(GOOGLETEST_GIT_REPO "https://github.com/google/googletest.git" CACHE STRING "A git repo to clone and build googletest from if gmock is not found in the system")
-
 find_package(GTest ${GOOGLETEST_VERSION} CONFIG)
 if (NOT TARGET GTest::gmock)
     # Try pkg-config if GTest was not found through CMake config
@@ -19,26 +16,26 @@ if (NOT TARGET GTest::gmock)
     if (NOT TARGET GTest::gmock)
         include(FetchContent)
 
-        message("Fetching googletest v${GOOGLETEST_VERSION}...")
+        if (GOOGLETEST_VERSION VERSION_GREATER_EQUAL 1.13.0)
+            set(GOOGLETEST_TAG "v${GOOGLETEST_VERSION}")
+        else()
+            set(GOOGLETEST_TAG "release-${GOOGLETEST_VERSION}")
+        endif()
+
+        message("Manually fetching & building googletest v${GOOGLETEST_VERSION}...")
         FetchContent_Declare(googletest
                             GIT_REPOSITORY ${GOOGLETEST_GIT_REPO}
-                            GIT_TAG        release-${GOOGLETEST_VERSION}
+                            GIT_TAG        ${GOOGLETEST_TAG}
                             GIT_SHALLOW    1
                             UPDATE_COMMAND "")
 
-        #FetchContent_MakeAvailable(googletest) # Not available in CMake 3.13 :-( Let's do it manually:
-        FetchContent_GetProperties(googletest)
-        if(NOT googletest_POPULATED)
-            FetchContent_Populate(googletest)
-            set(gtest_force_shared_crt ON CACHE INTERNAL "" FORCE)
-            set(BUILD_GMOCK ON CACHE INTERNAL "" FORCE)
-            set(INSTALL_GTEST OFF CACHE INTERNAL "" FORCE)
-            set(BUILD_SHARED_LIBS_BAK ${BUILD_SHARED_LIBS})
-            set(BUILD_SHARED_LIBS OFF)
-            add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
-            set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_BAK})
-            add_library(GTest::gmock ALIAS gmock)
-        endif()
+        set(gtest_force_shared_crt ON CACHE INTERNAL "" FORCE)
+        set(INSTALL_GTEST OFF CACHE INTERNAL "" FORCE)
+        set(BUILD_SHARED_LIBS_BAK ${BUILD_SHARED_LIBS})
+        set(BUILD_SHARED_LIBS OFF)
+        FetchContent_MakeAvailable(googletest)
+        set(BUILD_SHARED_LIBS ${BUILD_SHARED_LIBS_BAK})
+        add_library(GTest::gmock ALIAS gmock)
     endif()
 endif()
 
@@ -50,6 +47,7 @@ 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}/PollData_test.cpp
     ${UNITTESTS_SOURCE_DIR}/Types_test.cpp
     ${UNITTESTS_SOURCE_DIR}/TypeTraits_test.cpp
     ${UNITTESTS_SOURCE_DIR}/Connection_test.cpp
@@ -104,22 +102,29 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
 #----------------------------------
 
 add_executable(sdbus-c++-unit-tests ${UNITTESTS_SRCS})
-target_compile_definitions(sdbus-c++-unit-tests PRIVATE LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
+target_compile_definitions(sdbus-c++-unit-tests PRIVATE
+    LIBSYSTEMD_VERSION=${SDBUSCPP_LIBSYSTEMD_VERSION}
+    SDBUS_${LIBSYSTEMD_IMPL}
+    SDBUS_HEADER=<${LIBSYSTEMD_IMPL}/sd-bus.h>)
 target_link_libraries(sdbus-c++-unit-tests sdbus-c++-objlib GTest::gmock)
 
 add_executable(sdbus-c++-integration-tests ${INTEGRATIONTESTS_SRCS})
-target_compile_definitions(sdbus-c++-integration-tests PRIVATE LIBSYSTEMD_VERSION=${LIBSYSTEMD_VERSION})
-target_link_libraries(sdbus-c++-integration-tests sdbus-c++ GTest::gmock)
+target_compile_definitions(sdbus-c++-integration-tests PRIVATE
+    LIBSYSTEMD_VERSION=${SDBUSCPP_LIBSYSTEMD_VERSION}
+    SDBUS_${LIBSYSTEMD})
+if(NOT LIBSYSTEMD STREQUAL "basu")
+    # Systemd::Libsystemd is included because integration tests use sd-event. Otherwise sdbus-c++ encapsulates and hides libsystemd.
+    target_link_libraries(sdbus-c++-integration-tests sdbus-c++ Systemd::Libsystemd GTest::gmock)
+else()
+    # sd-event implementation is not part of basu, so its integration tests will be skipped
+    target_link_libraries(sdbus-c++-integration-tests sdbus-c++ GTest::gmock)
+endif()
 
-# 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)
+if(SDBUSCPP_BUILD_PERF_TESTS OR SDBUSCPP_BUILD_STRESS_TESTS)
     set(THREADS_PREFER_PTHREAD_FLAG ON)
     find_package(Threads REQUIRED)
 
-    if(ENABLE_PERF_TESTS)
+    if(SDBUSCPP_BUILD_PERF_TESTS)
         message(STATUS "Building with performance tests")
         add_executable(sdbus-c++-perf-tests-client ${STRESSTESTS_CLIENT_SRCS})
         target_link_libraries(sdbus-c++-perf-tests-client sdbus-c++ Threads::Threads)
@@ -127,7 +132,7 @@ if(ENABLE_PERF_TESTS OR ENABLE_STRESS_TESTS)
         target_link_libraries(sdbus-c++-perf-tests-server sdbus-c++ Threads::Threads)
     endif()
 
-    if(ENABLE_STRESS_TESTS)
+    if(SDBUSCPP_BUILD_STRESS_TESTS)
         message(STATUS "Building with stress tests")
         add_executable(sdbus-c++-stress-tests ${STRESSTESTS_SRCS})
         target_link_libraries(sdbus-c++-stress-tests sdbus-c++ Threads::Threads)
@@ -138,21 +143,26 @@ 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} COMPONENT test)
-install(TARGETS sdbus-c++-integration-tests DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
-install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/org.sdbuscpp.integrationtests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)
-
-if(ENABLE_PERF_TESTS)
-    install(TARGETS sdbus-c++-perf-tests-client DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
-    install(TARGETS sdbus-c++-perf-tests-server DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
-    install(FILES ${PERFTESTS_SOURCE_DIR}/files/org.sdbuscpp.perftests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)
-endif()
-
-if(ENABLE_STRESS_TESTS)
-    install(TARGETS sdbus-c++-stress-tests DESTINATION ${TESTS_INSTALL_PATH} COMPONENT test)
-    install(FILES ${STRESSTESTS_SOURCE_DIR}/files/org.sdbuscpp.stresstests.conf DESTINATION /etc/dbus-1/system.d COMPONENT test)
+if(SDBUSCPP_INSTALL)
+    include(GNUInstallDirs)
+    install(TARGETS sdbus-c++-unit-tests DESTINATION ${SDBUSCPP_TESTS_INSTALL_PATH} COMPONENT sdbus-c++-test)
+    install(TARGETS sdbus-c++-integration-tests DESTINATION ${SDBUSCPP_TESTS_INSTALL_PATH} COMPONENT sdbus-c++-test)
+    install(FILES ${INTEGRATIONTESTS_SOURCE_DIR}/files/org.sdbuscpp.integrationtests.conf
+            DESTINATION ${CMAKE_INSTALL_FULL_SYSCONFDIR}/dbus-1/system.d
+            COMPONENT sdbus-c++-test)
+    if(SDBUSCPP_BUILD_PERF_TESTS)
+        install(TARGETS sdbus-c++-perf-tests-client DESTINATION ${SDBUSCPP_TESTS_INSTALL_PATH} COMPONENT sdbus-c++-test)
+        install(TARGETS sdbus-c++-perf-tests-server DESTINATION ${SDBUSCPP_TESTS_INSTALL_PATH} COMPONENT sdbus-c++-test)
+        install(FILES ${PERFTESTS_SOURCE_DIR}/files/org.sdbuscpp.perftests.conf
+                DESTINATION ${CMAKE_INSTALL_FULL_SYSCONFDIR}/dbus-1/system.d
+                COMPONENT sdbus-c++-test)
+    endif()
+    if(SDBUSCPP_BUILD_STRESS_TESTS)
+        install(TARGETS sdbus-c++-stress-tests DESTINATION ${SDBUSCPP_TESTS_INSTALL_PATH} COMPONENT sdbus-c++-test)
+        install(FILES ${STRESSTESTS_SOURCE_DIR}/files/org.sdbuscpp.stresstests.conf
+                DESTINATION ${CMAKE_INSTALL_FULL_SYSCONFDIR}/dbus-1/system.d
+                COMPONENT sdbus-c++-test)
+    endif()
 endif()
 
 #----------------------------------
@@ -162,4 +172,4 @@ endif()
 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() 
+endif()

tests/integrationtests/DBusAsyncMethodsTests.cpp

@@ -49,29 +49,27 @@ using ::testing::SizeIs;
 using namespace std::chrono_literals;
 using namespace sdbus::test;
 
-using SdbusTestObject = TestFixture;
-
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
 /*-------------------------------------*/
 
-TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenClientSideAsyncMethodTimesOut)
+TYPED_TEST(AsyncSdbusTestObject, ThrowsTimeoutErrorWhenClientSideAsyncMethodTimesOut)
 {
     std::chrono::time_point<std::chrono::steady_clock> start;
     try
     {
         std::promise<uint32_t> promise;
         auto future = promise.get_future();
-        m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+        this->m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, std::optional<sdbus::Error> err)
         {
-            if (err == nullptr)
+            if (!err)
                 promise.set_value(res);
             else
-                promise.set_exception(std::make_exception_ptr(*err));
+                promise.set_exception(std::make_exception_ptr(*std::move(err)));
         });
 
         start = std::chrono::steady_clock::now();
-        m_proxy->doOperationClientSideAsyncWithTimeout(1us, 1000); // The operation will take 1s, but the timeout is 500ms, so we should time out
+        this->m_proxy->doOperationClientSideAsyncWithTimeout(1us, (1s).count()); // The operation will take 1s, but the timeout is 1us, so we should time out
         future.get();
 
         FAIL() << "Expected sdbus::Error exception";
@@ -89,7 +87,7 @@ TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenClientSideAsyncMethodTimesOut)
     }
 }
 
-TEST_F(SdbusTestObject, RunsServerSideAsynchoronousMethodAsynchronously)
+TYPED_TEST(AsyncSdbusTestObject, RunsServerSideAsynchoronousMethodAsynchronously)
 {
     // Yeah, this is kinda timing-dependent test, but times should be safe...
     std::mutex mtx;
@@ -114,7 +112,7 @@ TEST_F(SdbusTestObject, RunsServerSideAsynchoronousMethodAsynchronously)
     ASSERT_THAT(results, ElementsAre(500, 1000, 1500));
 }
 
-TEST_F(SdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
+TYPED_TEST(AsyncSdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
 {
     std::atomic<size_t> resultCount{};
     std::atomic<bool> invoke{};
@@ -144,97 +142,122 @@ TEST_F(SdbusTestObject, HandlesCorrectlyABulkOfParallelServerSideAsyncMethods)
     ASSERT_THAT(resultCount, Eq(1500));
 }
 
-TEST_F(SdbusTestObject, InvokesMethodAsynchronouslyOnClientSide)
+TYPED_TEST(AsyncSdbusTestObject, InvokesMethodAsynchronouslyOnClientSide)
 {
     std::promise<uint32_t> promise;
     auto future = promise.get_future();
-    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+    this->m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, std::optional<sdbus::Error> err)
     {
-        if (err == nullptr)
+        if (!err)
             promise.set_value(res);
         else
-            promise.set_exception(std::make_exception_ptr(*err));
+            promise.set_exception(std::make_exception_ptr(std::move(err)));
     });
 
-    m_proxy->doOperationClientSideAsync(100);
+    this->m_proxy->doOperationClientSideAsync(100);
 
     ASSERT_THAT(future.get(), Eq(100));
 }
 
-TEST_F(SdbusTestObject, AnswersThatAsyncCallIsPendingIfItIsInProgress)
+TYPED_TEST(AsyncSdbusTestObject, InvokesMethodAsynchronouslyOnClientSideWithFuture)
 {
-    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){});
+    auto future = this->m_proxy->doOperationClientSideAsync(100, sdbus::with_future);
 
-    auto call = m_proxy->doOperationClientSideAsync(100);
+    ASSERT_THAT(future.get(), Eq(100));
+}
+
+TYPED_TEST(AsyncSdbusTestObject, InvokesMethodAsynchronouslyOnClientSideWithFutureOnBasicAPILevel)
+{
+    auto future = this->m_proxy->doOperationClientSideAsyncOnBasicAPILevel(100);
+
+    auto methodReply = future.get();
+    uint32_t returnValue{};
+    methodReply >> returnValue;
+
+    ASSERT_THAT(returnValue, Eq(100));
+}
+
+TYPED_TEST(AsyncSdbusTestObject, AnswersThatAsyncCallIsPendingIfItIsInProgress)
+{
+    this->m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, std::optional<sdbus::Error> /*err*/){});
+
+    auto call = this->m_proxy->doOperationClientSideAsync(100);
 
     ASSERT_TRUE(call.isPending());
 }
 
-TEST_F(SdbusTestObject, CancelsPendingAsyncCallOnClientSide)
+TYPED_TEST(AsyncSdbusTestObject, 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);
+    this->m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, std::optional<sdbus::Error> /*err*/){ promise.set_value(1); });
+    auto call = this->m_proxy->doOperationClientSideAsync(100);
 
     call.cancel();
 
     ASSERT_THAT(future.wait_for(300ms), Eq(std::future_status::timeout));
 }
 
-TEST_F(SdbusTestObject, AnswersThatAsyncCallIsNotPendingAfterItHasBeenCancelled)
+TYPED_TEST(AsyncSdbusTestObject, 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);
+    this->m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, std::optional<sdbus::Error> /*err*/){ promise.set_value(1); });
+    auto call = this->m_proxy->doOperationClientSideAsync(100);
 
     call.cancel();
 
     ASSERT_FALSE(call.isPending());
 }
 
-TEST_F(SdbusTestObject, AnswersThatAsyncCallIsNotPendingAfterItHasBeenCompleted)
+TYPED_TEST(AsyncSdbusTestObject, 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); });
+    this->m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, std::optional<sdbus::Error> /*err*/){ promise.set_value(1); });
 
-    auto call = m_proxy->doOperationClientSideAsync(0);
+    auto call = this->m_proxy->doOperationClientSideAsync(0);
     (void) future.get(); // Wait for the call to finish
 
     ASSERT_TRUE(waitUntil([&call](){ return !call.isPending(); }));
 }
 
-TEST_F(SdbusTestObject, AnswersThatDefaultConstructedAsyncCallIsNotPending)
+TYPED_TEST(AsyncSdbusTestObject, AnswersThatDefaultConstructedAsyncCallIsNotPending)
 {
     sdbus::PendingAsyncCall call;
 
     ASSERT_FALSE(call.isPending());
 }
 
-TEST_F(SdbusTestObject, SupportsAsyncCallCopyAssignment)
+TYPED_TEST(AsyncSdbusTestObject, SupportsAsyncCallCopyAssignment)
 {
     sdbus::PendingAsyncCall call;
 
-    call = m_proxy->doOperationClientSideAsync(100);
+    call = this->m_proxy->doOperationClientSideAsync(100);
 
     ASSERT_TRUE(call.isPending());
 }
 
-TEST_F(SdbusTestObject, InvokesErroneousMethodAsynchronouslyOnClientSide)
+TYPED_TEST(AsyncSdbusTestObject, ReturnsNonnullErrorWhenAsynchronousMethodCallFails)
 {
     std::promise<uint32_t> promise;
     auto future = promise.get_future();
-    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, const sdbus::Error* err)
+    this->m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t res, std::optional<sdbus::Error> err)
     {
-        if (err == nullptr)
+        if (!err)
             promise.set_value(res);
         else
-            promise.set_exception(std::make_exception_ptr(*err));
+            promise.set_exception(std::make_exception_ptr(*std::move(err)));
     });
 
-    m_proxy->doErroneousOperationClientSideAsync();
+    this->m_proxy->doErroneousOperationClientSideAsync();
+
+    ASSERT_THROW(future.get(), sdbus::Error);
+}
+
+TYPED_TEST(AsyncSdbusTestObject, ThrowsErrorWhenClientSideAsynchronousMethodCallWithFutureFails)
+{
+    auto future = this->m_proxy->doErroneousOperationClientSideAsync(sdbus::with_future);
 
     ASSERT_THROW(future.get(), sdbus::Error);
 }

tests/integrationtests/DBusConnectionTests.cpp

@@ -41,7 +41,6 @@
 
 using ::testing::Eq;
 using namespace sdbus::test;
-using namespace std::chrono_literals;
 
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
@@ -49,12 +48,12 @@ using namespace std::chrono_literals;
 
 TEST(Connection, CanBeDefaultConstructed)
 {
-    ASSERT_NO_THROW(auto con = sdbus::createConnection());
+    ASSERT_NO_THROW(auto con = sdbus::createBusConnection());
 }
 
 TEST(Connection, CanRequestRegisteredDbusName)
 {
-    auto connection = sdbus::createConnection();
+    auto connection = sdbus::createBusConnection();
 
     ASSERT_NO_THROW(connection->requestName(BUS_NAME))
         << "Perhaps you've forgotten to copy `org.sdbuscpp.integrationtests.conf` file to `/etc/dbus-1/system.d` directory before running the tests?";
@@ -62,13 +61,13 @@ TEST(Connection, CanRequestRegisteredDbusName)
 
 TEST(Connection, CannotRequestNonregisteredDbusName)
 {
-    auto connection = sdbus::createConnection();
+    auto connection = sdbus::createBusConnection();
     ASSERT_THROW(connection->requestName("some.random.not.supported.dbus.name"), sdbus::Error);
 }
 
 TEST(Connection, CanReleasedRequestedName)
 {
-    auto connection = sdbus::createConnection();
+    auto connection = sdbus::createBusConnection();
 
     connection->requestName(BUS_NAME);
     ASSERT_NO_THROW(connection->releaseName(BUS_NAME));
@@ -76,13 +75,13 @@ TEST(Connection, CanReleasedRequestedName)
 
 TEST(Connection, CannotReleaseNonrequestedName)
 {
-    auto connection = sdbus::createConnection();
+    auto connection = sdbus::createBusConnection();
     ASSERT_THROW(connection->releaseName("some.random.nonrequested.name"), sdbus::Error);
 }
 
-TEST(Connection, CanEnterAndLeaveEventLoop)
+TEST(Connection, CanEnterAndLeaveInternalEventLoop)
 {
-    auto connection = sdbus::createConnection();
+    auto connection = sdbus::createBusConnection();
     connection->requestName(BUS_NAME);
 
     std::thread t([&](){ connection->enterEventLoop(); });
@@ -90,44 +89,3 @@ TEST(Connection, CanEnterAndLeaveEventLoop)
 
     t.join();
 }
-
-TEST(Connection, PollDataGetZeroTimeout)
-{
-    sdbus::IConnection::PollData pd{};
-    pd.timeout_usec = 0;
-    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
-    EXPECT_THAT(pd.getRelativeTimeout().value(), Eq(std::chrono::microseconds::zero()));
-    EXPECT_THAT(pd.getPollTimeout(), Eq(0));
-}
-
-TEST(Connection, PollDataGetInfiniteTimeout)
-{
-    sdbus::IConnection::PollData pd{};
-    pd.timeout_usec = UINT64_MAX;
-    ASSERT_FALSE(pd.getRelativeTimeout().has_value());
-    EXPECT_THAT(pd.getPollTimeout(), Eq(-1));
-}
-
-TEST(Connection, PollDataGetZeroRelativeTimeoutForPast)
-{
-    sdbus::IConnection::PollData pd{};
-    auto past = std::chrono::steady_clock::now() - 10s;
-    pd.timeout_usec = std::chrono::duration_cast<std::chrono::microseconds>(past.time_since_epoch()).count();
-    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
-    EXPECT_THAT(pd.getRelativeTimeout().value(), Eq(0us));
-    EXPECT_THAT(pd.getPollTimeout(), Eq(0));
-}
-
-TEST(Connection, PollDataGetRelativeTimeoutInTolerance)
-{
-    sdbus::IConnection::PollData pd{};
-    constexpr auto TIMEOUT = 1s;
-    constexpr auto TOLERANCE = 100ms;
-    auto future = std::chrono::steady_clock::now() + TIMEOUT;
-    pd.timeout_usec = std::chrono::duration_cast<std::chrono::microseconds>(future.time_since_epoch()).count();
-    ASSERT_TRUE(pd.getRelativeTimeout().has_value());
-    EXPECT_GE(pd.getRelativeTimeout().value(), TIMEOUT - TOLERANCE);
-    EXPECT_LE(pd.getRelativeTimeout().value(), TIMEOUT + TOLERANCE);
-    EXPECT_GE(pd.getPollTimeout(), 900);
-    EXPECT_LE(pd.getPollTimeout(), 1100);
-}

tests/integrationtests/DBusGeneralTests.cpp

@@ -38,13 +38,14 @@
 #include <fstream>
 #include <future>
 #include <unistd.h>
+#include <variant>
 
 using ::testing::ElementsAre;
 using ::testing::Eq;
 using namespace std::chrono_literals;
 using namespace sdbus::test;
 
-using AConnection = TestFixture;
+using ADirectConnection = TestFixtureWithDirectConnection;
 
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
@@ -52,81 +53,128 @@ using AConnection = TestFixture;
 
 TEST(AdaptorAndProxy, CanBeConstructedSuccesfully)
 {
-    auto connection = sdbus::createConnection();
+    auto connection = sdbus::createBusConnection();
     connection->requestName(BUS_NAME);
 
     ASSERT_NO_THROW(TestAdaptor adaptor(*connection, OBJECT_PATH));
     ASSERT_NO_THROW(TestProxy proxy(BUS_NAME, OBJECT_PATH));
 }
 
-TEST_F(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRule)
+TEST(AProxy, SupportsMoveSemantics)
+{
+    static_assert(std::is_move_constructible_v<DummyTestProxy>);
+    static_assert(std::is_move_assignable_v<DummyTestProxy>);
+}
+
+TEST(AnAdaptor, SupportsMoveSemantics)
+{
+    static_assert(std::is_move_constructible_v<DummyTestAdaptor>);
+    static_assert(std::is_move_assignable_v<DummyTestAdaptor>);
+}
+
+TYPED_TEST(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRule)
 {
     auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
     std::atomic<bool> matchingMessageReceived{false};
-    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    auto slot = this->s_proxyConnection->addMatch(matchRule, [&](sdbus::Message msg)
     {
         if(msg.getPath() == OBJECT_PATH)
             matchingMessageReceived = true;
     });
 
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
     ASSERT_TRUE(waitUntil(matchingMessageReceived));
 }
 
-TEST_F(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedSlot)
+TYPED_TEST(AConnection, CanInstallMatchRuleAsynchronously)
 {
     auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
     std::atomic<bool> matchingMessageReceived{false};
-    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    std::atomic<bool> matchRuleInstalled{false};
+    auto slot = this->s_proxyConnection->addMatchAsync( matchRule
+                                                      , [&](sdbus::Message msg)
+                                                        {
+                                                            if(msg.getPath() == OBJECT_PATH)
+                                                                matchingMessageReceived = true;
+                                                        }
+                                                      , [&](sdbus::Message /*msg*/)
+                                                        {
+                                                            matchRuleInstalled = true;
+                                                        } );
+
+    EXPECT_TRUE(waitUntil(matchRuleInstalled));
+
+    this->m_adaptor->emitSimpleSignal();
+
+    ASSERT_TRUE(waitUntil(matchingMessageReceived));
+}
+
+TYPED_TEST(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedSlot)
+{
+    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
+    std::atomic<bool> matchingMessageReceived{false};
+    auto slot = this->s_proxyConnection->addMatch(matchRule, [&](sdbus::Message msg)
     {
         if(msg.getPath() == OBJECT_PATH)
             matchingMessageReceived = true;
     });
     slot.reset();
 
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_FALSE(waitUntil(matchingMessageReceived, 2s));
+    ASSERT_FALSE(waitUntil(matchingMessageReceived, 1s));
 }
 
-TEST_F(AConnection, CanAddFloatingMatchRule)
+TYPED_TEST(AConnection, CanAddFloatingMatchRule)
 {
     auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
     std::atomic<bool> matchingMessageReceived{false};
     auto con = sdbus::createSystemBusConnection();
     con->enterEventLoopAsync();
-    auto callback = [&](sdbus::Message& msg)
+    auto callback = [&](sdbus::Message msg)
     {
         if(msg.getPath() == OBJECT_PATH)
             matchingMessageReceived = true;
     };
     con->addMatch(matchRule, std::move(callback), sdbus::floating_slot);
-    m_adaptor->emitSimpleSignal();
-    assert(waitUntil(matchingMessageReceived, 2s));
+    this->m_adaptor->emitSimpleSignal();
+    [[maybe_unused]] auto gotMessage = waitUntil(matchingMessageReceived, 2s);
+    assert(gotMessage);
     matchingMessageReceived = false;
 
     con.reset();
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_FALSE(waitUntil(matchingMessageReceived, 2s));
+    ASSERT_FALSE(waitUntil(matchingMessageReceived, 1s));
 }
 
-TEST_F(AConnection, WillNotPassToMatchCallbackMessagesThatDoNotMatchTheRule)
+TYPED_TEST(AConnection, WillNotPassToMatchCallbackMessagesThatDoNotMatchTheRule)
 {
     auto matchRule = "type='signal',interface='" + INTERFACE_NAME + "',member='simpleSignal'";
     std::atomic<size_t> numberOfMatchingMessages{};
-    auto slot = s_proxyConnection->addMatch(matchRule, [&](sdbus::Message& msg)
+    auto slot = this->s_proxyConnection->addMatch(matchRule, [&](sdbus::Message msg)
     {
         if(msg.getMemberName() == "simpleSignal")
             numberOfMatchingMessages++;
     });
-    auto adaptor2 = std::make_unique<TestAdaptor>(*s_adaptorConnection, OBJECT_PATH_2);
+    auto adaptor2 = std::make_unique<TestAdaptor>(*this->s_adaptorConnection, OBJECT_PATH_2);
 
-    m_adaptor->emitSignalWithMap({});
+    this->m_adaptor->emitSignalWithMap({});
     adaptor2->emitSimpleSignal();
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
     ASSERT_TRUE(waitUntil([&](){ return numberOfMatchingMessages == 2; }));
     ASSERT_FALSE(waitUntil([&](){ return numberOfMatchingMessages > 2; }, 1s));
 }
+
+// A simple direct connection test similar in nature to https://github.com/systemd/systemd/blob/main/src/libsystemd/sd-bus/test-bus-server.c
+TEST_F(ADirectConnection, CanBeUsedBetweenClientAndServer)
+{
+    auto val = m_proxy->sumArrayItems({1, 7}, {2, 3, 4});
+    m_adaptor->emitSimpleSignal();
+
+    // Make sure method call passes and emitted signal is received
+    ASSERT_THAT(val, Eq(1 + 7 + 2 + 3 + 4));
+    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+}

tests/integrationtests/DBusMethodsTests.cpp

@@ -50,135 +50,134 @@ using ::testing::NotNull;
 using namespace std::chrono_literals;
 using namespace sdbus::test;
 
-using SdbusTestObject = TestFixture;
-
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
 /*-------------------------------------*/
 
-TEST_F(SdbusTestObject, CallsEmptyMethodSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsEmptyMethodSuccesfully)
 {
-    ASSERT_NO_THROW(m_proxy->noArgNoReturn());
+    ASSERT_NO_THROW(this->m_proxy->noArgNoReturn());
 }
 
-TEST_F(SdbusTestObject, CallsMethodsWithBaseTypesSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodsWithBaseTypesSuccesfully)
 {
-    auto resInt = m_proxy->getInt();
+    auto resInt = this->m_proxy->getInt();
     ASSERT_THAT(resInt, Eq(INT32_VALUE));
 
-    auto multiplyRes = m_proxy->multiply(INT64_VALUE, DOUBLE_VALUE);
+    auto multiplyRes = this->m_proxy->multiply(INT64_VALUE, DOUBLE_VALUE);
     ASSERT_THAT(multiplyRes, Eq(INT64_VALUE * DOUBLE_VALUE));
 }
 
-TEST_F(SdbusTestObject, CallsMethodsWithTuplesSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodsWithTuplesSuccesfully)
 {
-    auto resTuple = m_proxy->getTuple();
+    auto resTuple = this->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)
+TYPED_TEST(SdbusTestObject, CallsMethodsWithStructSuccesfully)
 {
     sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>> a{};
-    auto vectorRes = m_proxy->getInts16FromStruct(a);
+    auto vectorRes = this->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);
+    vectorRes = this->m_proxy->getInts16FromStruct(b);
     ASSERT_THAT(vectorRes, Eq(std::vector<int16_t>{INT16_VALUE, INT16_VALUE, -INT16_VALUE}));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithVariantSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodWithVariantSuccesfully)
 {
     sdbus::Variant v{DOUBLE_VALUE};
-    auto variantRes = m_proxy->processVariant(v);
+    sdbus::Variant variantRes = this->m_proxy->processVariant(v);
     ASSERT_THAT(variantRes.get<int32_t>(), Eq(static_cast<int32_t>(DOUBLE_VALUE)));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithStructVariantsAndGetMapSuccesfully)
+TYPED_TEST(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}};
+    std::map<int32_t, sdbus::Variant> mapOfVariants = this->m_proxy->getMapOfVariants(x, y);
+    decltype(mapOfVariants) res{ {sdbus::Variant{-2}, sdbus::Variant{false}}
+                               , {sdbus::Variant{0}, sdbus::Variant{false}}
+                               , {sdbus::Variant{2}, sdbus::Variant{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)
+TYPED_TEST(SdbusTestObject, CallsMethodWithStructInStructSuccesfully)
 {
-    auto val = m_proxy->getStructInStruct();
-    ASSERT_THAT(val.get<0>(), Eq(STRING_VALUE));
+    auto val = this->m_proxy->getStructInStruct();
+    ASSERT_THAT(val.template get<0>(), Eq(STRING_VALUE));
     ASSERT_THAT(std::get<0>(std::get<1>(val))[INT32_VALUE], Eq(INT32_VALUE));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithTwoStructsSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodWithTwoStructsSuccesfully)
 {
-    auto val = m_proxy->sumStructItems({1, 2}, {3, 4});
+    auto val = this->m_proxy->sumStructItems({1, 2}, {3, 4});
     ASSERT_THAT(val, Eq(1 + 2 + 3 + 4));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithTwoVectorsSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodWithTwoVectorsSuccesfully)
 {
-    auto val = m_proxy->sumVectorItems({1, 7}, {2, 3});
-    ASSERT_THAT(val, Eq(1 + 7 + 2 + 3));
+    auto val = this->m_proxy->sumArrayItems({1, 7}, {2, 3, 4});
+    ASSERT_THAT(val, Eq(1 + 7 + 2 + 3 + 4));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithSignatureSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodWithSignatureSuccesfully)
 {
-    auto resSignature = m_proxy->getSignature();
+    auto resSignature = this->m_proxy->getSignature();
     ASSERT_THAT(resSignature, Eq(SIGNATURE_VALUE));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithObjectPathSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodWithObjectPathSuccesfully)
 {
-    auto resObjectPath = m_proxy->getObjPath();
+    auto resObjectPath = this->m_proxy->getObjPath();
     ASSERT_THAT(resObjectPath, Eq(OBJECT_PATH_VALUE));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithUnixFdSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodWithUnixFdSuccesfully)
 {
-    auto resUnixFd = m_proxy->getUnixFd();
+    auto resUnixFd = this->m_proxy->getUnixFd();
     ASSERT_THAT(resUnixFd.get(), Gt(UNIX_FD_VALUE));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithComplexTypeSuccesfully)
+TYPED_TEST(SdbusTestObject, CallsMethodWithComplexTypeSuccesfully)
 {
-    auto resComplex = m_proxy->getComplex();
+    auto resComplex = this->m_proxy->getComplex();
     ASSERT_THAT(resComplex.count(0), Eq(1));
 }
 
-TEST_F(SdbusTestObject, CallsMultiplyMethodWithNoReplyFlag)
+TYPED_TEST(SdbusTestObject, CallsMultiplyMethodWithNoReplyFlag)
 {
-    m_proxy->multiplyWithNoReply(INT64_VALUE, DOUBLE_VALUE);
+    this->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));
+    ASSERT_TRUE(waitUntil(this->m_adaptor->m_wasMultiplyCalled));
+    ASSERT_THAT(this->m_adaptor->m_multiplyResult, Eq(INT64_VALUE * DOUBLE_VALUE));
 }
 
-TEST_F(SdbusTestObject, CallsMethodWithCustomTimeoutSuccessfully)
+TYPED_TEST(SdbusTestObject, CallsMethodWithCustomTimeoutSuccessfully)
 {
-    auto res = m_proxy->doOperationWithTimeout(500ms, 20); // The operation will take 20ms, but the timeout is 500ms, so we are fine
+    auto res = this->m_proxy->doOperationWithTimeout(500ms, (20ms).count()); // The operation will take 20ms, but the timeout is 500ms, so we are fine
     ASSERT_THAT(res, Eq(20));
 }
 
-TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenMethodTimesOut)
+TYPED_TEST(SdbusTestObject, ThrowsTimeoutErrorWhenMethodTimesOut)
 {
     auto start = std::chrono::steady_clock::now();
     try
     {
-        m_proxy->doOperationWithTimeout(1us, 1000); // The operation will take 1s, but the timeout is 1us, so we should time out
+        this->m_proxy->doOperationWithTimeout(1us, (1s).count()); // The operation will take 1s, but the timeout is 1us, so we should time out
         FAIL() << "Expected sdbus::Error exception";
     }
     catch (const sdbus::Error& e)
     {
         ASSERT_THAT(e.getName(), AnyOf("org.freedesktop.DBus.Error.Timeout", "org.freedesktop.DBus.Error.NoReply"));
-        ASSERT_THAT(e.getMessage(), AnyOf("Connection timed out", "Method call timed out"));
+        ASSERT_THAT(e.getMessage(), AnyOf("Connection timed out", "Operation timed out", "Method call timed out"));
         auto measuredTimeout = std::chrono::steady_clock::now() - start;
         ASSERT_THAT(measuredTimeout, Le(50ms));
     }
@@ -188,11 +187,11 @@ TEST_F(SdbusTestObject, ThrowsTimeoutErrorWhenMethodTimesOut)
     }
 }
 
-TEST_F(SdbusTestObject, CallsMethodThatThrowsError)
+TYPED_TEST(SdbusTestObject, CallsMethodThatThrowsError)
 {
     try
     {
-        m_proxy->throwError();
+        this->m_proxy->throwError();
         FAIL() << "Expected sdbus::Error exception";
     }
     catch (const sdbus::Error& e)
@@ -206,69 +205,109 @@ TEST_F(SdbusTestObject, CallsMethodThatThrowsError)
     }
 }
 
-TEST_F(SdbusTestObject, CallsErrorThrowingMethodWithDontExpectReplySet)
+TYPED_TEST(SdbusTestObject, CallsErrorThrowingMethodWithDontExpectReplySet)
 {
-    ASSERT_NO_THROW(m_proxy->throwErrorWithNoReply());
+    ASSERT_NO_THROW(this->m_proxy->throwErrorWithNoReply());
 
-    ASSERT_TRUE(waitUntil(m_adaptor->m_wasThrowErrorCalled));
+    ASSERT_TRUE(waitUntil(this->m_adaptor->m_wasThrowErrorCalled));
 }
 
-TEST_F(SdbusTestObject, FailsCallingNonexistentMethod)
+TYPED_TEST(SdbusTestObject, FailsCallingNonexistentMethod)
 {
-    ASSERT_THROW(m_proxy->callNonexistentMethod(), sdbus::Error);
+    ASSERT_THROW(this->m_proxy->callNonexistentMethod(), sdbus::Error);
 }
 
-TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentInterface)
+TYPED_TEST(SdbusTestObject, FailsCallingMethodOnNonexistentInterface)
 {
-    ASSERT_THROW(m_proxy->callMethodOnNonexistentInterface(), sdbus::Error);
+    ASSERT_THROW(this->m_proxy->callMethodOnNonexistentInterface(), sdbus::Error);
 }
 
-TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentDestination)
+TYPED_TEST(SdbusTestObject, FailsCallingMethodOnNonexistentDestination)
 {
     TestProxy proxy("sdbuscpp.destination.that.does.not.exist", OBJECT_PATH);
     ASSERT_THROW(proxy.getInt(), sdbus::Error);
 }
 
-TEST_F(SdbusTestObject, FailsCallingMethodOnNonexistentObject)
+TYPED_TEST(SdbusTestObject, FailsCallingMethodOnNonexistentObject)
 {
     TestProxy proxy(BUS_NAME, "/sdbuscpp/path/that/does/not/exist");
     ASSERT_THROW(proxy.getInt(), sdbus::Error);
 }
 
-TEST_F(SdbusTestObject, CanReceiveSignalWhileMakingMethodCall)
+TYPED_TEST(SdbusTestObject, CanReceiveSignalWhileMakingMethodCall)
 {
-    m_proxy->emitTwoSimpleSignals();
+    this->m_proxy->emitTwoSimpleSignals();
 
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithMap));
+    EXPECT_TRUE(waitUntil(this->m_proxy->m_gotSimpleSignal));
+    EXPECT_TRUE(waitUntil(this->m_proxy->m_gotSignalWithMap));
 }
 
-TEST_F(SdbusTestObject, CanAccessAssociatedMethodCallMessageInMethodCallHandler)
+TYPED_TEST(SdbusTestObject, CanAccessAssociatedMethodCallMessageInMethodCallHandler)
 {
-    m_proxy->doOperation(10); // This will save pointer to method call message on server side
+    this->m_proxy->doOperation(10); // This will save pointer to method call message on server side
 
-    ASSERT_THAT(m_adaptor->m_methodCallMsg, NotNull());
-    ASSERT_THAT(m_adaptor->m_methodCallMemberName, Eq("doOperation"));
+    ASSERT_THAT(this->m_adaptor->m_methodCallMsg, NotNull());
+    ASSERT_THAT(this->m_adaptor->m_methodCallMemberName, Eq("doOperation"));
 }
 
-TEST_F(SdbusTestObject, CanAccessAssociatedMethodCallMessageInAsyncMethodCallHandler)
+TYPED_TEST(SdbusTestObject, CanAccessAssociatedMethodCallMessageInAsyncMethodCallHandler)
 {
-    m_proxy->doOperationAsync(10); // This will save pointer to method call message on server side
+    this->m_proxy->doOperationAsync(10); // This will save pointer to method call message on server side
 
-    ASSERT_THAT(m_adaptor->m_methodCallMsg, NotNull());
-    ASSERT_THAT(m_adaptor->m_methodCallMemberName, Eq("doOperationAsync"));
+    ASSERT_THAT(this->m_adaptor->m_methodCallMsg, NotNull());
+    ASSERT_THAT(this->m_adaptor->m_methodCallMemberName, Eq("doOperationAsync"));
 }
 
 #if LIBSYSTEMD_VERSION>=240
-TEST_F(SdbusTestObject, CanSetGeneralMethodTimeoutWithLibsystemdVersionGreaterThan239)
+TYPED_TEST(SdbusTestObject, CanSetGeneralMethodTimeoutWithLibsystemdVersionGreaterThan239)
 {
-    s_adaptorConnection->setMethodCallTimeout(5000000);
-    ASSERT_THAT(s_adaptorConnection->getMethodCallTimeout(), Eq(5000000));
+    this->s_adaptorConnection->setMethodCallTimeout(5000000);
+    ASSERT_THAT(this->s_adaptorConnection->getMethodCallTimeout(), Eq(5000000));
 }
 #else
-TEST_F(SdbusTestObject, CannotSetGeneralMethodTimeoutWithLibsystemdVersionLessThan240)
+TYPED_TEST(SdbusTestObject, CannotSetGeneralMethodTimeoutWithLibsystemdVersionLessThan240)
 {
-    ASSERT_THROW(s_adaptorConnection->setMethodCallTimeout(5000000), sdbus::Error);
-    ASSERT_THROW(s_adaptorConnection->getMethodCallTimeout(), sdbus::Error);
+    ASSERT_THROW(this->s_adaptorConnection->setMethodCallTimeout(5000000), sdbus::Error);
+    ASSERT_THROW(this->s_adaptorConnection->getMethodCallTimeout(), sdbus::Error);
 }
 #endif
+
+TYPED_TEST(SdbusTestObject, CanCallMethodSynchronouslyWithoutAnEventLoopThread)
+{
+    auto proxy = std::make_unique<TestProxy>(BUS_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
+
+    auto multiplyRes = proxy->multiply(INT64_VALUE, DOUBLE_VALUE);
+
+    ASSERT_THAT(multiplyRes, Eq(INT64_VALUE * DOUBLE_VALUE));
+}
+
+TYPED_TEST(SdbusTestObject, CanRegisterAdditionalVTableDynamicallyAtAnyTime)
+{
+    auto& object = this->m_adaptor->getObject();
+    auto vtableSlot = object.addVTable( "org.sdbuscpp.integrationtests2"
+                                      , { sdbus::registerMethod("add").implementedAs([](const int64_t& a, const double& b){ return a + b; })
+                                        , sdbus::registerMethod("subtract").implementedAs([](const int& a, const int& b){ return a - b; }) }
+                                      , sdbus::return_slot );
+
+    // The new remote vtable is registered as long as we keep vtableSlot, so remote method calls now should pass
+    auto proxy = sdbus::createProxy(BUS_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
+    int result{};
+    proxy->callMethod("subtract").onInterface("org.sdbuscpp.integrationtests2").withArguments(10, 2).storeResultsTo(result);
+
+    ASSERT_THAT(result, Eq(8));
+}
+
+TYPED_TEST(SdbusTestObject, CanUnregisterAdditionallyRegisteredVTableAtAnyTime)
+{
+    auto& object = this->m_adaptor->getObject();
+
+    auto vtableSlot = object.addVTable( "org.sdbuscpp.integrationtests2"
+                                      , { sdbus::registerMethod("add").implementedAs([](const int64_t& a, const double& b){ return a + b; })
+                                        , sdbus::registerMethod("subtract").implementedAs([](const int& a, const int& b){ return a - b; }) }
+                                      , sdbus::return_slot );
+    vtableSlot.reset(); // Letting the slot go means letting go the associated vtable registration
+
+    // No such remote D-Bus method under given interface exists anymore...
+    auto proxy = sdbus::createProxy(BUS_NAME, OBJECT_PATH, sdbus::dont_run_event_loop_thread);
+    ASSERT_THROW(proxy->callMethod("subtract").onInterface("org.sdbuscpp.integrationtests2").withArguments(10, 2), sdbus::Error);
+}

tests/integrationtests/DBusPropertiesTests.cpp

@@ -51,35 +51,33 @@ using ::testing::IsEmpty;
 using namespace std::chrono_literals;
 using namespace sdbus::test;
 
-using SdbusTestObject = TestFixture;
-
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
 /*-------------------------------------*/
 
-TEST_F(SdbusTestObject, ReadsReadOnlyPropertySuccesfully)
+TYPED_TEST(SdbusTestObject, ReadsReadOnlyPropertySuccesfully)
 {
-    ASSERT_THAT(m_proxy->state(), Eq(DEFAULT_STATE_VALUE));
+    ASSERT_THAT(this->m_proxy->state(), Eq(DEFAULT_STATE_VALUE));
 }
 
-TEST_F(SdbusTestObject, FailsWritingToReadOnlyProperty)
+TYPED_TEST(SdbusTestObject, FailsWritingToReadOnlyProperty)
 {
-    ASSERT_THROW(m_proxy->setStateProperty("new_value"), sdbus::Error);
+    ASSERT_THROW(this->m_proxy->setStateProperty("new_value"), sdbus::Error);
 }
 
-TEST_F(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
+TYPED_TEST(SdbusTestObject, WritesAndReadsReadWritePropertySuccesfully)
 {
     uint32_t newActionValue = 5678;
 
-    m_proxy->action(newActionValue);
+    this->m_proxy->action(newActionValue);
 
-    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+    ASSERT_THAT(this->m_proxy->action(), Eq(newActionValue));
 }
 
-TEST_F(SdbusTestObject, CanAccessAssociatedPropertySetMessageInPropertySetHandler)
+TYPED_TEST(SdbusTestObject, CanAccessAssociatedPropertySetMessageInPropertySetHandler)
 {
-    m_proxy->blocking(true); // This will save pointer to property get message on server side
+    this->m_proxy->blocking(true); // This will save pointer to property get message on server side
 
-    ASSERT_THAT(m_adaptor->m_propertySetMsg, NotNull());
-    ASSERT_THAT(m_adaptor->m_propertySetSender, Not(IsEmpty()));
+    ASSERT_THAT(this->m_adaptor->m_propertySetMsg, NotNull());
+    ASSERT_THAT(this->m_adaptor->m_propertySetSender, Not(IsEmpty()));
 }

tests/integrationtests/DBusSignalsTests.cpp

@@ -44,114 +44,124 @@ using ::testing::NotNull;
 using namespace std::chrono_literals;
 using namespace sdbus::test;
 
-using SdbusTestObject = TestFixture;
-
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
 /*-------------------------------------*/
 
-TEST_F(SdbusTestObject, EmitsSimpleSignalSuccesfully)
+TYPED_TEST(SdbusTestObject, EmitsSimpleSignalSuccesfully)
 {
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(this->m_proxy->m_gotSimpleSignal));
 }
 
-TEST_F(SdbusTestObject, EmitsSimpleSignalToMultipleProxiesSuccesfully)
+TYPED_TEST(SdbusTestObject, EmitsSimpleSignalToMultipleProxiesSuccesfully)
 {
-    auto proxy1 = std::make_unique<TestProxy>(*s_adaptorConnection, BUS_NAME, OBJECT_PATH);
-    auto proxy2 = std::make_unique<TestProxy>(*s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+    auto proxy1 = std::make_unique<TestProxy>(*this->s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestProxy>(*this->s_adaptorConnection, BUS_NAME, OBJECT_PATH);
 
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(this->m_proxy->m_gotSimpleSignal));
     ASSERT_TRUE(waitUntil(proxy1->m_gotSimpleSignal));
     ASSERT_TRUE(waitUntil(proxy2->m_gotSimpleSignal));
 }
 
-TEST_F(SdbusTestObject, ProxyDoesNotReceiveSignalFromOtherBusName)
+TYPED_TEST(SdbusTestObject, ProxyDoesNotReceiveSignalFromOtherBusName)
 {
     auto otherBusName = BUS_NAME + "2";
-    auto connection2 = sdbus::createConnection(otherBusName);
+    auto connection2 = sdbus::createBusConnection(otherBusName);
     auto adaptor2 = std::make_unique<TestAdaptor>(*connection2, OBJECT_PATH);
 
     adaptor2->emitSimpleSignal();
 
-    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, 2s));
+    ASSERT_FALSE(waitUntil(this->m_proxy->m_gotSimpleSignal, 1s));
 }
 
-TEST_F(SdbusTestObject, EmitsSignalWithMapSuccesfully)
+TYPED_TEST(SdbusTestObject, EmitsSignalWithMapSuccesfully)
 {
-    m_adaptor->emitSignalWithMap({{0, "zero"}, {1, "one"}});
+    this->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"));
+    ASSERT_TRUE(waitUntil(this->m_proxy->m_gotSignalWithMap));
+    ASSERT_THAT(this->m_proxy->m_mapFromSignal[0], Eq("zero"));
+    ASSERT_THAT(this->m_proxy->m_mapFromSignal[1], Eq("one"));
 }
 
-TEST_F(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
+TYPED_TEST(SdbusTestObject, EmitsSignalWithLargeMapSuccesfully)
+{
+  std::map<int32_t, std::string> largeMap;
+  for (int32_t i = 0; i < 20'000; ++i)
+      largeMap.emplace(i, "This is string nr. " + std::to_string(i+1));
+  this->m_adaptor->emitSignalWithMap(largeMap);
+
+  ASSERT_TRUE(waitUntil(this->m_proxy->m_gotSignalWithMap));
+  ASSERT_THAT(this->m_proxy->m_mapFromSignal[0], Eq("This is string nr. 1"));
+  ASSERT_THAT(this->m_proxy->m_mapFromSignal[1], Eq("This is string nr. 2"));
+}
+
+TYPED_TEST(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
 {
     double d = 3.14;
-    m_adaptor->emitSignalWithVariant(d);
+    this->m_adaptor->emitSignalWithVariant(sdbus::Variant{d});
 
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithVariant));
-    ASSERT_THAT(m_proxy->m_variantFromSignal, DoubleEq(d));
+    ASSERT_TRUE(waitUntil(this->m_proxy->m_gotSignalWithVariant));
+    ASSERT_THAT(this->m_proxy->m_variantFromSignal, DoubleEq(d));
 }
 
-TEST_F(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
+TYPED_TEST(SdbusTestObject, EmitsSignalWithoutRegistrationSuccesfully)
 {
-    m_adaptor->emitSignalWithoutRegistration({"platform", {"av"}});
+    this->m_adaptor->emitSignalWithoutRegistration({"platform", {"av"}});
 
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithSignature));
-    ASSERT_THAT(m_proxy->m_signatureFromSignal["platform"], Eq("av"));
+    ASSERT_TRUE(waitUntil(this->m_proxy->m_gotSignalWithSignature));
+    ASSERT_THAT(this->m_proxy->m_signatureFromSignal["platform"], Eq("av"));
 }
 
-TEST_F(SdbusTestObject, CanAccessAssociatedSignalMessageInSignalHandler)
+TYPED_TEST(SdbusTestObject, CanAccessAssociatedSignalMessageInSignalHandler)
 {
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
-    waitUntil(m_proxy->m_gotSimpleSignal);
+    waitUntil(this->m_proxy->m_gotSimpleSignal);
 
-    ASSERT_THAT(m_proxy->m_signalMsg, NotNull());
-    ASSERT_THAT(m_proxy->m_signalMemberName, Eq("simpleSignal"));
+    ASSERT_THAT(this->m_proxy->m_signalMsg, NotNull());
+    ASSERT_THAT(this->m_proxy->m_signalMemberName, Eq("simpleSignal"));
 }
 
-TEST_F(SdbusTestObject, UnregistersSignalHandler)
+TYPED_TEST(SdbusTestObject, UnregistersSignalHandler)
 {
-    ASSERT_NO_THROW(m_proxy->unregisterSimpleSignalHandler());
+    ASSERT_NO_THROW(this->m_proxy->unregisterSimpleSignalHandler());
 
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, 2s));
+    ASSERT_FALSE(waitUntil(this->m_proxy->m_gotSimpleSignal, 1s));
 }
 
-TEST_F(SdbusTestObject, UnregistersSignalHandlerForSomeProxies)
+TYPED_TEST(SdbusTestObject, UnregistersSignalHandlerForSomeProxies)
 {
-    auto proxy1 = std::make_unique<TestProxy>(*s_adaptorConnection, BUS_NAME, OBJECT_PATH);
-    auto proxy2 = std::make_unique<TestProxy>(*s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+    auto proxy1 = std::make_unique<TestProxy>(*this->s_adaptorConnection, BUS_NAME, OBJECT_PATH);
+    auto proxy2 = std::make_unique<TestProxy>(*this->s_adaptorConnection, BUS_NAME, OBJECT_PATH);
 
-    ASSERT_NO_THROW(m_proxy->unregisterSimpleSignalHandler());
+    ASSERT_NO_THROW(this->m_proxy->unregisterSimpleSignalHandler());
 
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
     ASSERT_TRUE(waitUntil(proxy1->m_gotSimpleSignal));
     ASSERT_TRUE(waitUntil(proxy2->m_gotSimpleSignal));
-    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, 2s));
+    ASSERT_FALSE(waitUntil(this->m_proxy->m_gotSimpleSignal, 1s));
 }
 
-TEST_F(SdbusTestObject, ReRegistersSignalHandler)
+TYPED_TEST(SdbusTestObject, ReRegistersSignalHandler)
 {
     // unregister simple-signal handler
-    ASSERT_NO_THROW(m_proxy->unregisterSimpleSignalHandler());
+    ASSERT_NO_THROW(this->m_proxy->unregisterSimpleSignalHandler());
 
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_FALSE(waitUntil(m_proxy->m_gotSimpleSignal, 2s));
+    ASSERT_FALSE(waitUntil(this->m_proxy->m_gotSimpleSignal, 1s));
 
     // re-register simple-signal handler
-    ASSERT_NO_THROW(m_proxy->reRegisterSimpleSignalHandler());
+    ASSERT_NO_THROW(this->m_proxy->reRegisterSimpleSignalHandler());
 
-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();
 
-    ASSERT_TRUE(waitUntil(m_proxy->m_gotSimpleSignal));
+    ASSERT_TRUE(waitUntil(this->m_proxy->m_gotSimpleSignal));
 }

tests/integrationtests/DBusStandardInterfacesTests.cpp

@@ -48,52 +48,118 @@ using ::testing::SizeIs;
 using namespace std::chrono_literals;
 using namespace sdbus::test;
 
-using SdbusTestObject = TestFixture;
-
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
 /*-------------------------------------*/
 
-TEST_F(SdbusTestObject, PingsViaPeerInterface)
+TYPED_TEST(SdbusTestObject, PingsViaPeerInterface)
 {
-    ASSERT_NO_THROW(m_proxy->Ping());
+    ASSERT_NO_THROW(this->m_proxy->Ping());
 }
 
-TEST_F(SdbusTestObject, AnswersMachineUuidViaPeerInterface)
+TYPED_TEST(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";
+    if (::access("/etc/machine-id", F_OK) == -1 &&
+        ::access("/var/lib/dbus/machine-id", F_OK) == -1)
+        GTEST_SKIP() << "/etc/machine-id and /var/lib/dbus/machine-id files do not exist, GetMachineId() will not work";
 
-    ASSERT_NO_THROW(m_proxy->GetMachineId());
+    ASSERT_NO_THROW(this->m_proxy->GetMachineId());
 }
 
 // TODO: Adjust expected xml and uncomment this test
-//TEST_F(SdbusTestObject, AnswersXmlApiDescriptionViaIntrospectableInterface)
+//TYPED_TEST(SdbusTestObject, AnswersXmlApiDescriptionViaIntrospectableInterface)
 //{
-//    ASSERT_THAT(m_proxy->Introspect(), Eq(m_adaptor->getExpectedXmlApiDescription()));
+//    ASSERT_THAT(this->m_proxy->Introspect(), Eq(this->m_adaptor->getExpectedXmlApiDescription()));
 //}
 
-TEST_F(SdbusTestObject, GetsPropertyViaPropertiesInterface)
+TYPED_TEST(SdbusTestObject, GetsPropertyViaPropertiesInterface)
 {
-    ASSERT_THAT(m_proxy->Get(INTERFACE_NAME, "state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    ASSERT_THAT(this->m_proxy->Get(INTERFACE_NAME, "state").template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
 }
 
-TEST_F(SdbusTestObject, SetsPropertyViaPropertiesInterface)
+TYPED_TEST(SdbusTestObject, GetsPropertyAsynchronouslyViaPropertiesInterface)
+{
+    std::promise<std::string> promise;
+    auto future = promise.get_future();
+
+    this->m_proxy->GetAsync(INTERFACE_NAME, "state", [&](std::optional<sdbus::Error> err, sdbus::Variant value)
+    {
+        if (!err)
+           promise.set_value(value.get<std::string>());
+        else
+           promise.set_exception(std::make_exception_ptr(*std::move(err)));
+    });
+
+    ASSERT_THAT(future.get(), Eq(DEFAULT_STATE_VALUE));
+}
+
+TYPED_TEST(SdbusTestObject, GetsPropertyAsynchronouslyViaPropertiesInterfaceWithFuture)
+{
+    auto future = this->m_proxy->GetAsync(INTERFACE_NAME, "state", sdbus::with_future);
+
+    ASSERT_THAT(future.get().template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+}
+
+TYPED_TEST(SdbusTestObject, SetsPropertyViaPropertiesInterface)
 {
     uint32_t newActionValue = 2345;
 
-    m_proxy->Set(INTERFACE_NAME, "action", newActionValue);
+    this->m_proxy->Set(INTERFACE_NAME, "action", sdbus::Variant{newActionValue});
 
-    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+    ASSERT_THAT(this->m_proxy->action(), Eq(newActionValue));
 }
 
-TEST_F(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
+TYPED_TEST(SdbusTestObject, SetsPropertyAsynchronouslyViaPropertiesInterface)
 {
-    const auto properties = m_proxy->GetAll(INTERFACE_NAME);
+    uint32_t newActionValue = 2346;
+    std::promise<void> promise;
+    auto future = promise.get_future();
+
+    this->m_proxy->SetAsync(INTERFACE_NAME, "action", sdbus::Variant{newActionValue}, [&](std::optional<sdbus::Error> err)
+    {
+        if (!err)
+            promise.set_value();
+        else
+            promise.set_exception(std::make_exception_ptr(*std::move(err)));
+    });
+
+    ASSERT_NO_THROW(future.get());
+    ASSERT_THAT(this->m_proxy->action(), Eq(newActionValue));
+}
+
+TYPED_TEST(SdbusTestObject, SetsPropertyAsynchronouslyViaPropertiesInterfaceWithFuture)
+{
+    uint32_t newActionValue = 2347;
+
+    auto future = this->m_proxy->SetAsync(INTERFACE_NAME, "action", sdbus::Variant{newActionValue}, sdbus::with_future);
+
+    ASSERT_NO_THROW(future.get());
+    ASSERT_THAT(this->m_proxy->action(), Eq(newActionValue));
+}
+
+TYPED_TEST(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
+{
+    const auto properties = this->m_proxy->GetAll(INTERFACE_NAME);
+
+    ASSERT_THAT(properties, SizeIs(3));
+    EXPECT_THAT(properties.at("state").template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    EXPECT_THAT(properties.at("action").template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(properties.at("blocking").template get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+}
+
+TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterface)
+{
+    std::promise<std::map<std::string, sdbus::Variant>> promise;
+    auto future = promise.get_future();
+
+    this->m_proxy->GetAllAsync(INTERFACE_NAME, [&](std::optional<sdbus::Error> err, std::map<std::string, sdbus::Variant> value)
+    {
+        if (!err)
+            promise.set_value(std::move(value));
+        else
+            promise.set_exception(std::make_exception_ptr(*std::move(err)));
+    });
+    const auto properties = future.get();
 
     ASSERT_THAT(properties, SizeIs(3));
     EXPECT_THAT(properties.at("state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
@@ -101,12 +167,24 @@ TEST_F(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
     EXPECT_THAT(properties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
 }
 
-TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
+TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterfaceWithFuture)
+{
+    auto future = this->m_proxy->GetAllAsync(INTERFACE_NAME, sdbus::with_future);
+
+    auto properties = future.get();
+
+    ASSERT_THAT(properties, SizeIs(3));
+    EXPECT_THAT(properties.at("state").template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    EXPECT_THAT(properties.at("action").template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+    EXPECT_THAT(properties.at("blocking").template get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+}
+
+TYPED_TEST(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*/ )
+    this->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));
@@ -114,19 +192,19 @@ TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
         signalReceived = true;
     };
 
-    m_proxy->blocking(!DEFAULT_BLOCKING_VALUE);
-    m_proxy->action(DEFAULT_ACTION_VALUE*2);
-    m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME, {"blocking"});
+    this->m_proxy->blocking(!DEFAULT_BLOCKING_VALUE);
+    this->m_proxy->action(DEFAULT_ACTION_VALUE*2);
+    this->m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME, {"blocking"});
 
     ASSERT_TRUE(waitUntil(signalReceived));
 }
 
-TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForAllProperties)
+TYPED_TEST(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 )
+    this->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));
@@ -136,38 +214,38 @@ TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForAllProperties)
         signalReceived = true;
     };
 
-    m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME);
+    this->m_adaptor->emitPropertiesChangedSignal(INTERFACE_NAME);
 
     ASSERT_TRUE(waitUntil(signalReceived));
 }
 
-TEST_F(SdbusTestObject, GetsZeroManagedObjectsIfHasNoSubPathObjects)
+TYPED_TEST(SdbusTestObject, GetsZeroManagedObjectsIfHasNoSubPathObjects)
 {
-    m_adaptor.reset();
-    const auto objectsInterfacesAndProperties = m_objectManagerProxy->GetManagedObjects();
+    this->m_adaptor.reset();
+    const auto objectsInterfacesAndProperties = this->m_objectManagerProxy->GetManagedObjects();
 
     ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(0));
 }
 
-TEST_F(SdbusTestObject, GetsManagedObjectsSuccessfully)
+TYPED_TEST(SdbusTestObject, GetsManagedObjectsSuccessfully)
 {
-    auto adaptor2 = std::make_unique<TestAdaptor>(*s_adaptorConnection, OBJECT_PATH_2);
-    const auto objectsInterfacesAndProperties = m_objectManagerProxy->GetManagedObjects();
+    auto adaptor2 = std::make_unique<TestAdaptor>(*this->s_adaptorConnection, OBJECT_PATH_2);
+    const auto objectsInterfacesAndProperties = this->m_objectManagerProxy->GetManagedObjects();
 
     ASSERT_THAT(objectsInterfacesAndProperties, SizeIs(2));
     EXPECT_THAT(objectsInterfacesAndProperties.at(OBJECT_PATH)
         .at(org::sdbuscpp::integrationtests_adaptor::INTERFACE_NAME)
-        .at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+        .at("action").template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
     EXPECT_THAT(objectsInterfacesAndProperties.at(OBJECT_PATH_2)
         .at(org::sdbuscpp::integrationtests_adaptor::INTERFACE_NAME)
-        .at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
+        .at("action").template get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
 }
 
-TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterfaces)
+TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterfaces)
 {
     std::atomic<bool> signalReceived{false};
-    m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-            , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+    this->m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                                              , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
     {
         EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
         EXPECT_THAT(interfacesAndProperties, SizeIs(1));
@@ -189,19 +267,25 @@ TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForSelectedObjectInterfaces)
         signalReceived = true;
     };
 
-    m_adaptor->emitInterfacesAddedSignal({INTERFACE_NAME});
+    this->m_adaptor->emitInterfacesAddedSignal({INTERFACE_NAME});
 
     ASSERT_TRUE(waitUntil(signalReceived));
 }
 
-TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces)
+TYPED_TEST(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces)
 {
     std::atomic<bool> signalReceived{false};
-    m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-            , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
+    this->m_objectManagerProxy->m_onInterfacesAddedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                                              , const std::map<std::string, std::map<std::string, sdbus::Variant>>& interfacesAndProperties )
     {
         EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+#if LIBSYSTEMD_VERSION<=250
         EXPECT_THAT(interfacesAndProperties, SizeIs(5)); // INTERFACE_NAME + 4 standard interfaces
+#else
+        // Since systemd v251, ObjectManager standard interface is not listed among the interfaces
+        // if the object does not have object manager functionality explicitly enabled.
+        EXPECT_THAT(interfacesAndProperties, SizeIs(4)); // INTERFACE_NAME + 3 standard interfaces
+#endif
 #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));
@@ -219,16 +303,16 @@ TEST_F(SdbusTestObject, EmitsInterfacesAddedSignalForAllObjectInterfaces)
         signalReceived = true;
     };
 
-    m_adaptor->emitInterfacesAddedSignal();
+    this->m_adaptor->emitInterfacesAddedSignal();
 
     ASSERT_TRUE(waitUntil(signalReceived));
 }
 
-TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfaces)
+TYPED_TEST(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfaces)
 {
     std::atomic<bool> signalReceived{false};
-    m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                                          , const std::vector<std::string>& interfaces )
+    this->m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                                                , const std::vector<std::string>& interfaces )
     {
         EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
         ASSERT_THAT(interfaces, SizeIs(1));
@@ -236,23 +320,29 @@ TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForSelectedObjectInterfaces)
         signalReceived = true;
     };
 
-    m_adaptor->emitInterfacesRemovedSignal({INTERFACE_NAME});
+    this->m_adaptor->emitInterfacesRemovedSignal({INTERFACE_NAME});
 
     ASSERT_TRUE(waitUntil(signalReceived));
 }
 
-TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForAllObjectInterfaces)
+TYPED_TEST(SdbusTestObject, EmitsInterfacesRemovedSignalForAllObjectInterfaces)
 {
     std::atomic<bool> signalReceived{false};
-    m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
-                                                                          , const std::vector<std::string>& interfaces )
+    this->m_objectManagerProxy->m_onInterfacesRemovedHandler = [&signalReceived]( const sdbus::ObjectPath& objectPath
+                                                                                , const std::vector<std::string>& interfaces )
     {
         EXPECT_THAT(objectPath, Eq(OBJECT_PATH));
+#if LIBSYSTEMD_VERSION<=250
         ASSERT_THAT(interfaces, SizeIs(5)); // INTERFACE_NAME + 4 standard interfaces
+#else
+        // Since systemd v251, ObjectManager standard interface is not listed among the interfaces
+        // if the object does not have object manager functionality explicitly enabled.
+        ASSERT_THAT(interfaces, SizeIs(4)); // INTERFACE_NAME + 3 standard interfaces
+#endif
         signalReceived = true;
     };
 
-    m_adaptor->emitInterfacesRemovedSignal();
+    this->m_adaptor->emitInterfacesRemovedSignal();
 
     ASSERT_TRUE(waitUntil(signalReceived));
 }

tests/integrationtests/Defs.h

@@ -30,14 +30,17 @@
 #include "sdbus-c++/Types.h"
 #include <chrono>
 #include <ostream>
+#include <filesystem>
 
 namespace sdbus { namespace test {
 
 const std::string INTERFACE_NAME{"org.sdbuscpp.integrationtests"};
 const std::string BUS_NAME = INTERFACE_NAME;
+const std::string EMPTY_DESTINATION;
 const std::string MANAGER_PATH {"/org/sdbuscpp/integrationtests"};
 const std::string OBJECT_PATH  {"/org/sdbuscpp/integrationtests/ObjectA1"};
 const std::string OBJECT_PATH_2{"/org/sdbuscpp/integrationtests/ObjectB1"};
+const std::string DIRECT_CONNECTION_SOCKET_PATH{std::filesystem::temp_directory_path() / "sdbus-cpp-direct-connection-test"};
 
 constexpr const uint8_t UINT8_VALUE{1};
 constexpr const int16_t INT16_VALUE{21};

tests/integrationtests/TestAdaptor.cpp

@@ -30,7 +30,7 @@
 #include <atomic>
 
 namespace sdbus { namespace test {
-    
+
 TestAdaptor::TestAdaptor(sdbus::IConnection& connection, const std::string& path) :
     AdaptorInterfaces(connection, path)
 {
@@ -77,7 +77,7 @@ std::vector<int16_t> TestAdaptor::getInts16FromStruct(const sdbus::Struct<uint8_
 
 sdbus::Variant TestAdaptor::processVariant(const sdbus::Variant& v)
 {
-    sdbus::Variant res = static_cast<int32_t>(v.get<double>());
+    sdbus::Variant res{static_cast<int32_t>(v.get<double>())};
     return res;
 }
 
@@ -93,7 +93,7 @@ std::map<int32_t, sdbus::Variant> TestAdaptor::getMapOfVariants(const std::vecto
 
 sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> TestAdaptor::getStructInStruct()
 {
-    return sdbus::make_struct(STRING_VALUE, sdbus::make_struct(std::map<int32_t, int32_t>{{INT32_VALUE, INT32_VALUE}}));
+    return sdbus::Struct{STRING_VALUE, sdbus::Struct{std::map<int32_t, int32_t>{{INT32_VALUE, INT32_VALUE}}}};
 }
 
 int32_t TestAdaptor::sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, const sdbus::Struct<int32_t, int64_t>& b)
@@ -104,7 +104,7 @@ int32_t TestAdaptor::sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& a, c
     return res;
 }
 
-uint32_t TestAdaptor::sumVectorItems(const std::vector<uint16_t>& a, const std::vector<uint64_t>& b)
+uint32_t TestAdaptor::sumArrayItems(const std::vector<uint16_t>& a, const std::array<uint64_t, 3>& b)
 {
     uint32_t res{0};
     for (auto x : a)
@@ -122,7 +122,7 @@ uint32_t TestAdaptor::doOperation(const uint32_t& param)
 {
     std::this_thread::sleep_for(std::chrono::milliseconds(param));
 
-    m_methodCallMsg = getObject().getCurrentlyProcessedMessage();
+    m_methodCallMsg = std::make_unique<const Message>(getObject().getCurrentlyProcessedMessage());
     m_methodCallMemberName = m_methodCallMsg->getMemberName();
 
     return param;
@@ -130,7 +130,7 @@ uint32_t TestAdaptor::doOperation(const uint32_t& param)
 
 void TestAdaptor::doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t param)
 {
-    m_methodCallMsg = getObject().getCurrentlyProcessedMessage();
+    m_methodCallMsg = std::make_unique<const Message>(getObject().getCurrentlyProcessedMessage());
     m_methodCallMemberName = m_methodCallMsg->getMemberName();
 
     if (param == 0)
@@ -162,9 +162,9 @@ sdbus::UnixFd TestAdaptor::getUnixFd()
     return sdbus::UnixFd{UNIX_FD_VALUE};
 }
 
-std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> TestAdaptor::getComplex()
+std::unordered_map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> TestAdaptor::getComplex()
 {
-    return { // map
+    return { // unordered_map
         {
             0,  // uint_64_t
             {   // struct
@@ -234,7 +234,7 @@ bool TestAdaptor::blocking()
 
 void TestAdaptor::blocking(const bool& value)
 {
-    m_propertySetMsg = getObject().getCurrentlyProcessedMessage();
+    m_propertySetMsg = std::make_unique<const Message>(getObject().getCurrentlyProcessedMessage());
     m_propertySetSender = m_propertySetMsg->getSender();
 
     m_blocking = value;
@@ -390,7 +390,7 @@ R"delimiter(
 <arg type="(ix)" direction="in"/>
 <arg type="i" direction="out"/>
 </method>
-<method name="sumVectorItems">
+<method name="sumArrayItems">
 <arg type="aq" direction="in"/>
 <arg type="at" direction="in"/>
 <arg type="u" direction="out"/>

tests/integrationtests/TestAdaptor.h

@@ -33,6 +33,7 @@
 #include <chrono>
 #include <atomic>
 #include <utility>
+#include <memory>
 
 namespace sdbus { namespace test {
 
@@ -70,13 +71,13 @@ protected:
     std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) override;
     sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() override;
     int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1) override;
-    uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1) override;
+    uint32_t sumArrayItems(const std::vector<uint16_t>& arg0, const std::array<uint64_t, 3>& arg1) override;
     uint32_t doOperation(const uint32_t& arg0) override;
     void doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t arg0) override;
     sdbus::Signature getSignature() override;
     sdbus::ObjectPath getObjPath() override;
     sdbus::UnixFd getUnixFd() override;
-    std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() override;
+    std::unordered_map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() override;
     void throwError() override;
     void throwErrorWithNoReply() override;
     void doPrivilegedStuff() override;
@@ -103,12 +104,49 @@ public: // for tests
     mutable double m_multiplyResult{};
     mutable std::atomic<bool> m_wasThrowErrorCalled{false};
 
-    const Message* m_methodCallMsg{};
+    std::unique_ptr<const Message> m_methodCallMsg;
     std::string m_methodCallMemberName;
-    const Message* m_propertySetMsg{};
+    std::unique_ptr<const Message> m_propertySetMsg;
     std::string m_propertySetSender;
 };
 
+class DummyTestAdaptor final : public sdbus::AdaptorInterfaces< org::sdbuscpp::integrationtests_adaptor
+                                                              , sdbus::Properties_adaptor
+                                                              , sdbus::ManagedObject_adaptor >
+{
+public:
+    DummyTestAdaptor(sdbus::IConnection& connection, const std::string& path) : AdaptorInterfaces(connection, path) {}
+
+protected:
+    void noArgNoReturn() override {}
+    int32_t getInt() override { return {}; }
+    std::tuple<uint32_t, std::string> getTuple() override { return {}; }
+    double multiply(const int64_t&, const double&) override { return {}; }
+    void multiplyWithNoReply(const int64_t&, const double&) override {}
+    std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>&) override { return {}; }
+    sdbus::Variant processVariant(const sdbus::Variant&) override { return {}; }
+    std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>&, const sdbus::Struct<sdbus::Variant, sdbus::Variant>&) override { return {}; }
+    sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() override { return {}; }
+    int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>&, const sdbus::Struct<int32_t, int64_t>&) override { return {}; }
+    uint32_t sumArrayItems(const std::vector<uint16_t>&, const std::array<uint64_t, 3>&) override { return {}; }
+    uint32_t doOperation(const uint32_t&) override { return {}; }
+    void doOperationAsync(sdbus::Result<uint32_t>&&, uint32_t) override {}
+    sdbus::Signature getSignature() override { return {}; }
+    sdbus::ObjectPath getObjPath() override { return {}; }
+    sdbus::UnixFd getUnixFd() override { return {}; }
+    std::unordered_map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() override { return {}; }
+    void throwError() override {}
+    void throwErrorWithNoReply() override {}
+    void doPrivilegedStuff() override {}
+    void emitTwoSimpleSignals() override {}
+
+    uint32_t action() override { return {}; }
+    void action(const uint32_t&) override {}
+    bool blocking() override { return {}; }
+    void blocking(const bool&) override {}
+    std::string state() override { return {}; }
+};
+
 }}
 
 #endif /* INTEGRATIONTESTS_TESTADAPTOR_H_ */

tests/integrationtests/TestFixture.cpp

@@ -2,7 +2,7 @@
  * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
  * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
- * @file TestAdaptor.cpp
+ * @file TestFixture.cpp
  *
  * Created on: May 23, 2020
  * Project: sdbus-c++
@@ -27,8 +27,18 @@
 #include "TestFixture.h"
 
 namespace sdbus { namespace test {
-    
-std::unique_ptr<sdbus::IConnection> TestFixture::s_adaptorConnection = sdbus::createSystemBusConnection();
-std::unique_ptr<sdbus::IConnection> TestFixture::s_proxyConnection = sdbus::createSystemBusConnection();
+
+std::unique_ptr<sdbus::IConnection> BaseTestFixture::s_adaptorConnection = sdbus::createSystemBusConnection();
+std::unique_ptr<sdbus::IConnection> BaseTestFixture::s_proxyConnection = sdbus::createSystemBusConnection();
+
+#ifndef SDBUS_basu // sd_event integration is not supported in basu-based sdbus-c++
+
+std::thread TestFixture<SdEventLoop>::s_adaptorEventLoopThread{};
+std::thread TestFixture<SdEventLoop>::s_proxyEventLoopThread{};
+sd_event *TestFixture<SdEventLoop>::s_adaptorSdEvent{};
+sd_event *TestFixture<SdEventLoop>::s_proxySdEvent{};
+int TestFixture<SdEventLoop>::s_eventExitFd{-1};
+
+#endif // SDBUS_basu
 
 }}

tests/integrationtests/TestFixture.h

@@ -2,7 +2,7 @@
  * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
  * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
- * @file TestAdaptor.h
+ * @file TestFixture.h
  *
  * Created on: Jan 2, 2017
  * Project: sdbus-c++
@@ -33,52 +33,34 @@
 
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
+#ifndef SDBUS_basu // sd_event integration is not supported in basu-based sdbus-c++
+#include <systemd/sd-event.h>
+#endif // SDBUS_basu
+#include <sys/eventfd.h>
 
 #include <thread>
 #include <chrono>
 #include <atomic>
 #include <chrono>
 
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/un.h>
+
 namespace sdbus { namespace test {
 
-class TestFixture : public ::testing::Test
+class BaseTestFixture : public ::testing::Test
 {
 public:
     static void SetUpTestCase()
     {
-        s_proxyConnection->enterEventLoopAsync();
         s_adaptorConnection->requestName(BUS_NAME);
-        s_adaptorConnection->enterEventLoopAsync();
-        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // Give time for the proxy connection to start listening to signals
     }
 
     static void TearDownTestCase()
     {
         s_adaptorConnection->releaseName(BUS_NAME);
-        s_adaptorConnection->leaveEventLoop();
-        s_proxyConnection->leaveEventLoop();
-    }
-
-    template <typename _Fnc>
-    static bool waitUntil(_Fnc&& fnc, std::chrono::milliseconds timeout = std::chrono::seconds(5))
-    {
-        using namespace std::chrono_literals;
-
-        std::chrono::milliseconds elapsed{};
-        std::chrono::milliseconds step{5ms};
-        do {
-            std::this_thread::sleep_for(step);
-            elapsed += step;
-            if (elapsed > timeout)
-                return false;
-        } while (!fnc());
-
-        return true;
-    }
-
-    static bool waitUntil(std::atomic<bool>& flag, std::chrono::milliseconds timeout = std::chrono::seconds(5))
-    {
-        return waitUntil([&flag]() -> bool { return flag; }, timeout);
     }
 
 private:
@@ -106,6 +88,203 @@ public:
     std::unique_ptr<TestProxy> m_proxy;
 };
 
+struct SdBusCppLoop{};
+struct SdEventLoop{};
+
+template <typename _EventLoop>
+class TestFixture : public BaseTestFixture{};
+
+// Fixture working upon internal sdbus-c++ event loop
+template <>
+class TestFixture<SdBusCppLoop> : public BaseTestFixture
+{
+public:
+    static void SetUpTestCase()
+    {
+        BaseTestFixture::SetUpTestCase();
+        s_proxyConnection->enterEventLoopAsync();
+        s_adaptorConnection->enterEventLoopAsync();
+        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // Give time for the proxy connection to start listening to signals
+    }
+
+    static void TearDownTestCase()
+    {
+        BaseTestFixture::TearDownTestCase();
+        s_adaptorConnection->leaveEventLoop();
+        s_proxyConnection->leaveEventLoop();
+    }
+};
+
+#ifndef SDBUS_basu // sd_event integration is not supported in basu-based sdbus-c++
+
+// Fixture working upon attached external sd-event loop
+template <>
+class TestFixture<SdEventLoop> : public BaseTestFixture
+{
+public:
+    static void SetUpTestCase()
+    {
+        sd_event_new(&s_adaptorSdEvent);
+        sd_event_new(&s_proxySdEvent);
+
+        s_adaptorConnection->attachSdEventLoop(s_adaptorSdEvent);
+        s_proxyConnection->attachSdEventLoop(s_proxySdEvent);
+
+        s_eventExitFd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
+        auto exitHandler = [](sd_event_source *s, auto...){ return sd_event_exit(sd_event_source_get_event(s), 0); };
+        sd_event_add_io(s_adaptorSdEvent, nullptr, s_eventExitFd, EPOLLIN, exitHandler, nullptr);
+        sd_event_add_io(s_proxySdEvent, nullptr, s_eventExitFd, EPOLLIN, exitHandler, nullptr);
+
+        s_adaptorEventLoopThread = std::thread([]()
+        {
+            sd_event_loop(s_adaptorSdEvent);
+        });
+        s_proxyEventLoopThread = std::thread([]()
+        {
+            sd_event_loop(s_proxySdEvent);
+        });
+
+        BaseTestFixture::SetUpTestCase();
+        std::this_thread::sleep_for(std::chrono::milliseconds(50)); // Give time for the proxy connection to start listening to signals
+    }
+
+    static void TearDownTestCase()
+    {
+        (void)eventfd_write(s_eventExitFd, 1);
+
+        s_adaptorEventLoopThread.join();
+        s_proxyEventLoopThread.join();
+
+        sd_event_unref(s_adaptorSdEvent);
+        sd_event_unref(s_proxySdEvent);
+        close(s_eventExitFd);
+
+        BaseTestFixture::TearDownTestCase();
+    }
+
+private:
+    static std::thread s_adaptorEventLoopThread;
+    static std::thread s_proxyEventLoopThread;
+    static sd_event *s_adaptorSdEvent;
+    static sd_event *s_proxySdEvent;
+    static int s_eventExitFd;
+};
+
+typedef ::testing::Types<SdBusCppLoop, SdEventLoop> EventLoopTags;
+
+#else // SDBUS_basu
+typedef ::testing::Types<SdBusCppLoop> EventLoopTags;
+#endif // SDBUS_basu
+
+TYPED_TEST_SUITE(TestFixture, EventLoopTags);
+
+template <typename _EventLoop>
+using SdbusTestObject = TestFixture<_EventLoop>;
+TYPED_TEST_SUITE(SdbusTestObject, EventLoopTags);
+
+template <typename _EventLoop>
+using AsyncSdbusTestObject = TestFixture<_EventLoop>;
+TYPED_TEST_SUITE(AsyncSdbusTestObject, EventLoopTags);
+
+template <typename _EventLoop>
+using AConnection = TestFixture<_EventLoop>;
+TYPED_TEST_SUITE(AConnection, EventLoopTags);
+
+class TestFixtureWithDirectConnection : public ::testing::Test
+{
+private:
+    void SetUp() override
+    {
+        int sock = openUnixSocket();
+        createClientAndServerConnections(sock);
+        createAdaptorAndProxyObjects();
+    }
+
+    void TearDown() override
+    {
+        m_proxy.reset();
+        m_adaptor.reset();
+        m_proxyConnection->leaveEventLoop();
+        m_adaptorConnection->leaveEventLoop();
+    }
+
+    static int openUnixSocket()
+    {
+        int sock = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
+        assert(sock >= 0);
+
+        sockaddr_un sa;
+        memset(&sa, 0, sizeof(sa));
+        sa.sun_family = AF_UNIX;
+        snprintf(sa.sun_path, sizeof(sa.sun_path), "%s", DIRECT_CONNECTION_SOCKET_PATH.c_str());
+
+        unlink(DIRECT_CONNECTION_SOCKET_PATH.c_str());
+
+        umask(0000);
+        [[maybe_unused]] int r = bind(sock, (const sockaddr*) &sa, sizeof(sa.sun_path));
+        assert(r >= 0);
+
+        r = listen(sock, 5);
+        assert(r >= 0);
+
+        return sock;
+    }
+
+    void createClientAndServerConnections(int sock)
+    {
+        std::thread t([&]()
+        {
+            auto fd = accept4(sock, NULL, NULL, /*SOCK_NONBLOCK|*/SOCK_CLOEXEC);
+            m_adaptorConnection = sdbus::createServerBus(fd);
+            // This is necessary so that createDirectBusConnection() below does not block
+            m_adaptorConnection->enterEventLoopAsync();
+        });
+
+        m_proxyConnection = sdbus::createDirectBusConnection("unix:path=" + DIRECT_CONNECTION_SOCKET_PATH);
+        m_proxyConnection->enterEventLoopAsync();
+
+        t.join();
+    }
+
+    void createAdaptorAndProxyObjects()
+    {
+        assert(m_adaptorConnection != nullptr);
+        assert(m_proxyConnection != nullptr);
+
+        m_adaptor = std::make_unique<TestAdaptor>(*m_adaptorConnection, OBJECT_PATH);
+        // Destination parameter can be empty in case of direct connections
+        m_proxy = std::make_unique<TestProxy>(*m_proxyConnection, EMPTY_DESTINATION, OBJECT_PATH);
+    }
+
+public:
+    std::unique_ptr<sdbus::IConnection> m_adaptorConnection;
+    std::unique_ptr<sdbus::IConnection> m_proxyConnection;
+    std::unique_ptr<TestAdaptor> m_adaptor;
+    std::unique_ptr<TestProxy> m_proxy;
+};
+
+template <typename _Fnc>
+inline bool waitUntil(_Fnc&& fnc, std::chrono::milliseconds timeout = std::chrono::seconds(5))
+{
+    using namespace std::chrono_literals;
+
+    std::chrono::milliseconds elapsed{};
+    std::chrono::milliseconds step{5ms};
+    do {
+        std::this_thread::sleep_for(step);
+        elapsed += step;
+        if (elapsed > timeout)
+            return false;
+    } while (!fnc());
+
+    return true;
+}
+
+inline bool waitUntil(std::atomic<bool>& flag, std::chrono::milliseconds timeout = std::chrono::seconds(5))
+{
+    return waitUntil([&flag]() -> bool { return flag; }, timeout);
+}
+
 }}
 
 #endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTFIXTURE_H_ */

tests/integrationtests/TestProxy.cpp

@@ -2,7 +2,7 @@
  * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
  * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
- * @file TestAdaptor.cpp
+ * @file TestProxy.cpp
  *
  * Created on: May 23, 2020
  * Project: sdbus-c++
@@ -30,7 +30,7 @@
 #include <atomic>
 
 namespace sdbus { namespace test {
-    
+
 TestProxy::TestProxy(std::string destination, std::string objectPath)
     : ProxyInterfaces(std::move(destination), std::move(objectPath))
 {
@@ -39,6 +39,13 @@ TestProxy::TestProxy(std::string destination, std::string objectPath)
     registerProxy();
 }
 
+TestProxy::TestProxy(std::string destination, std::string objectPath, dont_run_event_loop_thread_t)
+    : ProxyInterfaces(std::move(destination), std::move(objectPath), dont_run_event_loop_thread)
+{
+    // It doesn't make sense to register any signals here since proxy upon a D-Bus connection with no event loop thread
+    // will not receive any incoming messages except replies to synchronous D-Bus calls.
+}
+
 TestProxy::TestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath)
     : ProxyInterfaces(connection, std::move(destination), std::move(objectPath))
 {
@@ -54,7 +61,7 @@ TestProxy::~TestProxy()
 
 void TestProxy::onSimpleSignal()
 {
-    m_signalMsg = getProxy().getCurrentlyProcessedMessage();
+    m_signalMsg = std::make_unique<sdbus::Message>(getProxy().getCurrentlyProcessedMessage());
     m_signalMemberName = m_signalMsg->getMemberName();
 
     m_gotSimpleSignal = true;
@@ -78,7 +85,7 @@ void TestProxy::onSignalWithoutRegistration(const sdbus::Struct<std::string, sdb
     m_gotSignalWithSignature = true;
 }
 
-void TestProxy::onDoOperationReply(uint32_t returnValue, const sdbus::Error* error)
+void TestProxy::onDoOperationReply(uint32_t returnValue, std::optional<sdbus::Error> error)
 {
     if (m_DoOperationClientSideAsyncReplyHandler)
         m_DoOperationClientSideAsyncReplyHandler(returnValue, error);
@@ -92,7 +99,7 @@ void TestProxy::onPropertiesChanged( const std::string& interfaceName
         m_onPropertiesChangedHandler(interfaceName, changedProperties, invalidatedProperties);
 }
 
-void TestProxy::installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler)
+void TestProxy::installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, std::optional<sdbus::Error> err)> handler)
 {
     m_DoOperationClientSideAsyncReplyHandler = std::move(handler);
 }
@@ -110,22 +117,45 @@ sdbus::PendingAsyncCall TestProxy::doOperationClientSideAsync(uint32_t param)
     return getProxy().callMethodAsync("doOperation")
                      .onInterface(sdbus::test::INTERFACE_NAME)
                      .withArguments(param)
-                     .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
+                     .uponReplyInvoke([this](std::optional<sdbus::Error> error, uint32_t returnValue)
                                       {
-                                          this->onDoOperationReply(returnValue, error);
+                                          this->onDoOperationReply(returnValue, std::move(error));
                                       });
 }
 
+std::future<uint32_t> TestProxy::doOperationClientSideAsync(uint32_t param, with_future_t)
+{
+    return getProxy().callMethodAsync("doOperation")
+                     .onInterface(sdbus::test::INTERFACE_NAME)
+                     .withArguments(param)
+                     .getResultAsFuture<uint32_t>();
+}
+
+std::future<MethodReply> TestProxy::doOperationClientSideAsyncOnBasicAPILevel(uint32_t param)
+{
+    auto methodCall = getProxy().createMethodCall(sdbus::test::INTERFACE_NAME, "doOperation");
+    methodCall << param;
+
+    return getProxy().callMethodAsync(methodCall, sdbus::with_future);
+}
+
 void TestProxy::doErroneousOperationClientSideAsync()
 {
     getProxy().callMethodAsync("throwError")
               .onInterface(sdbus::test::INTERFACE_NAME)
-              .uponReplyInvoke([this](const sdbus::Error* error)
+              .uponReplyInvoke([this](std::optional<sdbus::Error> error)
                                {
-                                   this->onDoOperationReply(0, error);
+                                   this->onDoOperationReply(0, std::move(error));
                                });
 }
 
+std::future<void> TestProxy::doErroneousOperationClientSideAsync(with_future_t)
+{
+    return getProxy().callMethodAsync("throwError")
+                     .onInterface(sdbus::test::INTERFACE_NAME)
+                     .getResultAsFuture<>();
+}
+
 void TestProxy::doOperationClientSideAsyncWithTimeout(const std::chrono::microseconds &timeout, uint32_t param)
 {
     using namespace std::chrono_literals;
@@ -133,9 +163,9 @@ void TestProxy::doOperationClientSideAsyncWithTimeout(const std::chrono::microse
               .onInterface(sdbus::test::INTERFACE_NAME)
               .withTimeout(timeout)
               .withArguments(param)
-              .uponReplyInvoke([this](const sdbus::Error* error, uint32_t returnValue)
+              .uponReplyInvoke([this](std::optional<sdbus::Error> error, uint32_t returnValue)
                                {
-                                   this->onDoOperationReply(returnValue, error);
+                                   this->onDoOperationReply(returnValue, std::move(error));
                                });
 }
 

tests/integrationtests/TestProxy.h

@@ -2,7 +2,7 @@
  * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
  * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
  *
- * @file TestAdaptor.h
+ * @file TestProxy.h
  *
  * Created on: Jan 2, 2017
  * Project: sdbus-c++
@@ -32,6 +32,8 @@
 #include <thread>
 #include <chrono>
 #include <atomic>
+#include <future>
+#include <memory>
 
 namespace sdbus { namespace test {
 
@@ -73,6 +75,7 @@ class TestProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::integratio
 {
 public:
     TestProxy(std::string destination, std::string objectPath);
+    TestProxy(std::string destination, std::string objectPath, dont_run_event_loop_thread_t);
     TestProxy(sdbus::IConnection& connection, std::string destination, std::string objectPath);
     ~TestProxy();
 
@@ -82,7 +85,7 @@ protected:
     void onSignalWithVariant(const sdbus::Variant& aVariant) override;
 
     void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>& s);
-    void onDoOperationReply(uint32_t returnValue, const sdbus::Error* error);
+    void onDoOperationReply(uint32_t returnValue, std::optional<sdbus::Error> error);
 
     // Signals of standard D-Bus interfaces
     void onPropertiesChanged( const std::string& interfaceName
@@ -90,9 +93,12 @@ protected:
                             , const std::vector<std::string>& invalidatedProperties ) override;
 
 public:
-    void installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, const sdbus::Error* err)> handler);
+    void installDoOperationClientSideAsyncReplyHandler(std::function<void(uint32_t res, std::optional<sdbus::Error> err)> handler);
     uint32_t doOperationWithTimeout(const std::chrono::microseconds &timeout, uint32_t param);
     sdbus::PendingAsyncCall doOperationClientSideAsync(uint32_t param);
+    std::future<uint32_t> doOperationClientSideAsync(uint32_t param, with_future_t);
+    std::future<MethodReply> doOperationClientSideAsyncOnBasicAPILevel(uint32_t param);
+    std::future<void> doErroneousOperationClientSideAsync(with_future_t);
     void doErroneousOperationClientSideAsync();
     void doOperationClientSideAsyncWithTimeout(const std::chrono::microseconds &timeout, uint32_t param);
     int32_t callNonexistentMethod();
@@ -110,13 +116,36 @@ public: // for tests
     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(uint32_t res, std::optional<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;
 
-    const Message* m_signalMsg{};
+    std::unique_ptr<const Message> m_signalMsg;
     std::string m_signalMemberName;
 };
 
+class DummyTestProxy final : public sdbus::ProxyInterfaces< org::sdbuscpp::integrationtests_proxy
+                                                          , sdbus::Peer_proxy
+                                                          , sdbus::Introspectable_proxy
+                                                          , sdbus::Properties_proxy >
+{
+public:
+    DummyTestProxy(std::string destination, std::string objectPath)
+        : ProxyInterfaces(destination, objectPath)
+    {
+    }
+
+protected:
+    void onSimpleSignal() override {}
+    void onSignalWithMap(const std::map<int32_t, std::string>&) override {}
+    void onSignalWithVariant(const sdbus::Variant&) override {}
+
+    void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>&) {}
+    void onDoOperationReply(uint32_t, std::optional<sdbus::Error>) {}
+
+    // Signals of standard D-Bus interfaces
+    void onPropertiesChanged( const std::string&, const std::map<std::string, sdbus::Variant>&, const std::vector<std::string>& ) override {}
+};
+
 }}
 
 #endif /* SDBUS_CPP_INTEGRATIONTESTS_TESTPROXY_H_ */

tests/integrationtests/integrationtests-adaptor.h

@@ -20,54 +20,64 @@ public:
 
 protected:
     integrationtests_adaptor(sdbus::IObject& object)
-        : object_(object)
+        : object_(&object)
     {
-        object_.setInterfaceFlags(INTERFACE_NAME).markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
-        object_.registerMethod("noArgNoReturn").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->noArgNoReturn(); });
-        object_.registerMethod("getInt").onInterface(INTERFACE_NAME).withOutputParamNames("anInt").implementedAs([this](){ return this->getInt(); });
-        object_.registerMethod("getTuple").onInterface(INTERFACE_NAME).withOutputParamNames("arg0", "arg1").implementedAs([this](){ return this->getTuple(); });
-        object_.registerMethod("multiply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").withOutputParamNames("result").implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); });
-        object_.registerMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").implementedAs([this](const int64_t& a, const double& b){ return this->multiplyWithNoReply(a, b); }).markAsDeprecated().withNoReply();
-        object_.registerMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0){ return this->getInts16FromStruct(arg0); });
-        object_.registerMethod("processVariant").onInterface(INTERFACE_NAME).withInputParamNames("variant").withOutputParamNames("result").implementedAs([this](const sdbus::Variant& variant){ return this->processVariant(variant); });
-        object_.registerMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withInputParamNames("x", "y").withOutputParamNames("aMapOfVariants").implementedAs([this](const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y){ return this->getMapOfVariants(x, y); });
-        object_.registerMethod("getStructInStruct").onInterface(INTERFACE_NAME).withOutputParamNames("aMapOfVariants").implementedAs([this](){ return this->getStructInStruct(); });
-        object_.registerMethod("sumStructItems").onInterface(INTERFACE_NAME).withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1){ return this->sumStructItems(arg0, arg1); });
-        object_.registerMethod("sumVectorItems").onInterface(INTERFACE_NAME).withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1){ return this->sumVectorItems(arg0, arg1); });
-        object_.registerMethod("doOperation").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const uint32_t& arg0){ return this->doOperation(arg0); });
-        object_.registerMethod("doOperationAsync").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](sdbus::Result<uint32_t>&& result, uint32_t arg0){ this->doOperationAsync(std::move(result), std::move(arg0)); });
-        object_.registerMethod("getSignature").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getSignature(); });
-        object_.registerMethod("getObjPath").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getObjPath(); });
-        object_.registerMethod("getUnixFd").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getUnixFd(); });
-        object_.registerMethod("getComplex").onInterface(INTERFACE_NAME).withOutputParamNames("arg0").implementedAs([this](){ return this->getComplex(); }).markAsDeprecated();
-        object_.registerMethod("throwError").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->throwError(); });
-        object_.registerMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->throwErrorWithNoReply(); }).withNoReply();
-        object_.registerMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->doPrivilegedStuff(); }).markAsPrivileged();
-        object_.registerMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->emitTwoSimpleSignals(); });
-        object_.registerSignal("simpleSignal").onInterface(INTERFACE_NAME).markAsDeprecated();
-        object_.registerSignal("signalWithMap").onInterface(INTERFACE_NAME).withParameters<std::map<int32_t, std::string>>("aMap");
-        object_.registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>("aVariant");
-        object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_INVALIDATION_SIGNAL);
-        object_.registerProperty("blocking").onInterface(INTERFACE_NAME).withGetter([this](){ return this->blocking(); }).withSetter([this](const bool& value){ this->blocking(value); });
-        object_.registerProperty("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE);
     }
 
+    integrationtests_adaptor(const integrationtests_adaptor&) = delete;
+    integrationtests_adaptor& operator=(const integrationtests_adaptor&) = delete;
+    integrationtests_adaptor(integrationtests_adaptor&&) = default;
+    integrationtests_adaptor& operator=(integrationtests_adaptor&&) = default;
+
     ~integrationtests_adaptor() = default;
 
+    void registerAdaptor()
+    {
+        object_->addVTable( sdbus::setInterfaceFlags().markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL)
+                          , sdbus::registerMethod("noArgNoReturn").implementedAs([this](){ return this->noArgNoReturn(); })
+                          , sdbus::registerMethod("getInt").withOutputParamNames("anInt").implementedAs([this](){ return this->getInt(); })
+                          , sdbus::registerMethod("getTuple").withOutputParamNames("arg0", "arg1").implementedAs([this](){ return this->getTuple(); })
+                          , sdbus::registerMethod("multiply").withInputParamNames("a", "b").withOutputParamNames("result").implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); })
+                          , sdbus::registerMethod("multiplyWithNoReply").withInputParamNames("a", "b").implementedAs([this](const int64_t& a, const double& b){ return this->multiplyWithNoReply(a, b); }).markAsDeprecated().withNoReply()
+                          , sdbus::registerMethod("getInts16FromStruct").withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0){ return this->getInts16FromStruct(arg0); })
+                          , sdbus::registerMethod("processVariant").withInputParamNames("variant").withOutputParamNames("result").implementedAs([this](const sdbus::Variant& variant){ return this->processVariant(variant); })
+                          , sdbus::registerMethod("getMapOfVariants").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); })
+                          , sdbus::registerMethod("getStructInStruct").withOutputParamNames("aMapOfVariants").implementedAs([this](){ return this->getStructInStruct(); })
+                          , sdbus::registerMethod("sumStructItems").withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1){ return this->sumStructItems(arg0, arg1); })
+                          , sdbus::registerMethod("sumArrayItems").withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const std::vector<uint16_t>& arg0, const std::array<uint64_t, 3>& arg1){ return this->sumArrayItems(arg0, arg1); })
+                          , sdbus::registerMethod("doOperation").withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const uint32_t& arg0){ return this->doOperation(arg0); })
+                          , sdbus::registerMethod("doOperationAsync").withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](sdbus::Result<uint32_t>&& result, uint32_t arg0){ this->doOperationAsync(std::move(result), std::move(arg0)); })
+                          , sdbus::registerMethod("getSignature").withOutputParamNames("arg0").implementedAs([this](){ return this->getSignature(); })
+                          , sdbus::registerMethod("getObjPath").withOutputParamNames("arg0").implementedAs([this](){ return this->getObjPath(); })
+                          , sdbus::registerMethod("getUnixFd").withOutputParamNames("arg0").implementedAs([this](){ return this->getUnixFd(); })
+                          , sdbus::registerMethod("getComplex").withOutputParamNames("arg0").implementedAs([this](){ return this->getComplex(); }).markAsDeprecated()
+                          , sdbus::registerMethod("throwError").implementedAs([this](){ return this->throwError(); })
+                          , sdbus::registerMethod("throwErrorWithNoReply").implementedAs([this](){ return this->throwErrorWithNoReply(); }).withNoReply()
+                          , sdbus::registerMethod("doPrivilegedStuff").implementedAs([this](){ return this->doPrivilegedStuff(); }).markAsPrivileged()
+                          , sdbus::registerMethod("emitTwoSimpleSignals").implementedAs([this](){ return this->emitTwoSimpleSignals(); })
+                          , sdbus::registerSignal("simpleSignal").markAsDeprecated()
+                          , sdbus::registerSignal("signalWithMap").withParameters<std::map<int32_t, std::string>>("aMap")
+                          , sdbus::registerSignal("signalWithVariant").withParameters<sdbus::Variant>("aVariant")
+                          , sdbus::registerProperty("action").withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_INVALIDATION_SIGNAL)
+                          , sdbus::registerProperty("blocking").withGetter([this](){ return this->blocking(); }).withSetter([this](const bool& value){ this->blocking(value); })
+                          , sdbus::registerProperty("state").withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE)
+                          ).forInterface(INTERFACE_NAME);
+    }
+
 public:
     void emitSimpleSignal()
     {
-        object_.emitSignal("simpleSignal").onInterface(INTERFACE_NAME);
+        object_->emitSignal("simpleSignal").onInterface(INTERFACE_NAME);
     }
 
     void emitSignalWithMap(const std::map<int32_t, std::string>& aMap)
     {
-        object_.emitSignal("signalWithMap").onInterface(INTERFACE_NAME).withArguments(aMap);
+        object_->emitSignal("signalWithMap").onInterface(INTERFACE_NAME).withArguments(aMap);
     }
 
     void emitSignalWithVariant(const sdbus::Variant& aVariant)
     {
-        object_.emitSignal("signalWithVariant").onInterface(INTERFACE_NAME).withArguments(aVariant);
+        object_->emitSignal("signalWithVariant").onInterface(INTERFACE_NAME).withArguments(aVariant);
     }
 
 private:
@@ -81,13 +91,13 @@ private:
     virtual std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y) = 0;
     virtual sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct() = 0;
     virtual int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1) = 0;
-    virtual uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1) = 0;
+    virtual uint32_t sumArrayItems(const std::vector<uint16_t>& arg0, const std::array<uint64_t, 3>& arg1) = 0;
     virtual uint32_t doOperation(const uint32_t& arg0) = 0;
     virtual void doOperationAsync(sdbus::Result<uint32_t>&& result, uint32_t arg0) = 0;
     virtual sdbus::Signature getSignature() = 0;
     virtual sdbus::ObjectPath getObjPath() = 0;
     virtual sdbus::UnixFd getUnixFd() = 0;
-    virtual std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() = 0;
+    virtual std::unordered_map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex() = 0;
     virtual void throwError() = 0;
     virtual void throwErrorWithNoReply() = 0;
     virtual void doPrivilegedStuff() = 0;
@@ -101,7 +111,7 @@ private:
     virtual std::string state() = 0;
 
 private:
-    sdbus::IObject& object_;
+    sdbus::IObject* object_;
 };
 
 }} // namespaces

tests/integrationtests/integrationtests-proxy.h

@@ -20,15 +20,24 @@ public:
 
 protected:
     integrationtests_proxy(sdbus::IProxy& proxy)
-        : proxy_(proxy)
+        : proxy_(&proxy)
     {
-        proxy_.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
-        proxy_.uponSignal("signalWithMap").onInterface(INTERFACE_NAME).call([this](const std::map<int32_t, std::string>& aMap){ this->onSignalWithMap(aMap); });
-        proxy_.uponSignal("signalWithVariant").onInterface(INTERFACE_NAME).call([this](const sdbus::Variant& aVariant){ this->onSignalWithVariant(aVariant); });
     }
 
+    integrationtests_proxy(const integrationtests_proxy&) = delete;
+    integrationtests_proxy& operator=(const integrationtests_proxy&) = delete;
+    integrationtests_proxy(integrationtests_proxy&&) = default;
+    integrationtests_proxy& operator=(integrationtests_proxy&&) = default;
+
     ~integrationtests_proxy() = default;
 
+    void registerProxy()
+    {
+        simpleSignalSlot_ = proxy_->uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); }, sdbus::return_slot);
+        proxy_->uponSignal("signalWithMap").onInterface(INTERFACE_NAME).call([this](const std::map<int32_t, std::string>& aMap){ this->onSignalWithMap(aMap); });
+        proxy_->uponSignal("signalWithVariant").onInterface(INTERFACE_NAME).call([this](const sdbus::Variant& aVariant){ this->onSignalWithVariant(aVariant); });
+    }
+
     virtual void onSimpleSignal() = 0;
     virtual void onSignalWithMap(const std::map<int32_t, std::string>& aMap) = 0;
     virtual void onSignalWithVariant(const sdbus::Variant& aVariant) = 0;
@@ -36,178 +45,178 @@ protected:
 public:
     void noArgNoReturn()
     {
-        proxy_.callMethod("noArgNoReturn").onInterface(INTERFACE_NAME);
+        proxy_->callMethod("noArgNoReturn").onInterface(INTERFACE_NAME);
     }
 
     int32_t getInt()
     {
         int32_t result;
-        proxy_.callMethod("getInt").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        proxy_->callMethod("getInt").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
     std::tuple<uint32_t, std::string> getTuple()
     {
         std::tuple<uint32_t, std::string> result;
-        proxy_.callMethod("getTuple").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        proxy_->callMethod("getTuple").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
     double multiply(const int64_t& a, const double& b)
     {
         double result;
-        proxy_.callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
+        proxy_->callMethod("multiply").onInterface(INTERFACE_NAME).withArguments(a, b).storeResultsTo(result);
         return result;
     }
 
     void multiplyWithNoReply(const int64_t& a, const double& b)
     {
-        proxy_.callMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withArguments(a, b).dontExpectReply();
+        proxy_->callMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withArguments(a, b).dontExpectReply();
     }
 
     std::vector<int16_t> getInts16FromStruct(const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0)
     {
         std::vector<int16_t> result;
-        proxy_.callMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        proxy_->callMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
         return result;
     }
 
     sdbus::Variant processVariant(const sdbus::Variant& variant)
     {
         sdbus::Variant result;
-        proxy_.callMethod("processVariant").onInterface(INTERFACE_NAME).withArguments(variant).storeResultsTo(result);
+        proxy_->callMethod("processVariant").onInterface(INTERFACE_NAME).withArguments(variant).storeResultsTo(result);
         return result;
     }
 
     std::map<int32_t, sdbus::Variant> getMapOfVariants(const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y)
     {
         std::map<int32_t, sdbus::Variant> result;
-        proxy_.callMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withArguments(x, y).storeResultsTo(result);
+        proxy_->callMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withArguments(x, y).storeResultsTo(result);
         return result;
     }
 
     sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> getStructInStruct()
     {
         sdbus::Struct<std::string, sdbus::Struct<std::map<int32_t, int32_t>>> result;
-        proxy_.callMethod("getStructInStruct").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        proxy_->callMethod("getStructInStruct").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
     int32_t sumStructItems(const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1)
     {
         int32_t result;
-        proxy_.callMethod("sumStructItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
+        proxy_->callMethod("sumStructItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
         return result;
     }
 
-    uint32_t sumVectorItems(const std::vector<uint16_t>& arg0, const std::vector<uint64_t>& arg1)
+    uint32_t sumArrayItems(const std::vector<uint16_t>& arg0, const std::array<uint64_t, 3>& arg1)
     {
         uint32_t result;
-        proxy_.callMethod("sumVectorItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
+        proxy_->callMethod("sumArrayItems").onInterface(INTERFACE_NAME).withArguments(arg0, arg1).storeResultsTo(result);
         return result;
     }
 
     uint32_t doOperation(const uint32_t& arg0)
     {
         uint32_t result;
-        proxy_.callMethod("doOperation").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        proxy_->callMethod("doOperation").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
         return result;
     }
 
     uint32_t doOperationAsync(const uint32_t& arg0)
     {
         uint32_t result;
-        proxy_.callMethod("doOperationAsync").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
+        proxy_->callMethod("doOperationAsync").onInterface(INTERFACE_NAME).withArguments(arg0).storeResultsTo(result);
         return result;
     }
 
     sdbus::Signature getSignature()
     {
         sdbus::Signature result;
-        proxy_.callMethod("getSignature").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        proxy_->callMethod("getSignature").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
     sdbus::ObjectPath getObjPath()
     {
         sdbus::ObjectPath result;
-        proxy_.callMethod("getObjPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        proxy_->callMethod("getObjPath").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
     sdbus::UnixFd getUnixFd()
     {
         sdbus::UnixFd result;
-        proxy_.callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        proxy_->callMethod("getUnixFd").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
-    std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex()
+    std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::unordered_map<int32_t, std::string>>>>, sdbus::Signature, std::string>> getComplex()
     {
-        std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::map<int32_t, std::string>>>>, sdbus::Signature, std::string>> result;
-        proxy_.callMethod("getComplex").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        std::map<uint64_t, sdbus::Struct<std::map<uint8_t, std::vector<sdbus::Struct<sdbus::ObjectPath, bool, sdbus::Variant, std::unordered_map<int32_t, std::string>>>>, sdbus::Signature, std::string>> result;
+        proxy_->callMethod("getComplex").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
     void throwError()
     {
-        proxy_.callMethod("throwError").onInterface(INTERFACE_NAME);
+        proxy_->callMethod("throwError").onInterface(INTERFACE_NAME);
     }
 
     void throwErrorWithNoReply()
     {
-        proxy_.callMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).dontExpectReply();
+        proxy_->callMethod("throwErrorWithNoReply").onInterface(INTERFACE_NAME).dontExpectReply();
     }
 
     void doPrivilegedStuff()
     {
-        proxy_.callMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME);
+        proxy_->callMethod("doPrivilegedStuff").onInterface(INTERFACE_NAME);
     }
 
     void emitTwoSimpleSignals()
     {
-        proxy_.callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME);
+        proxy_->callMethod("emitTwoSimpleSignals").onInterface(INTERFACE_NAME);
     }
 
     void unregisterSimpleSignalHandler()
     {
-        proxy_.muteSignal("simpleSignal").onInterface(INTERFACE_NAME);
+        simpleSignalSlot_.reset();
     }
 
     void reRegisterSimpleSignalHandler()
     {
-        proxy_.uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
-        proxy_.finishRegistration();
+        simpleSignalSlot_ = proxy_->uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); }, sdbus::return_slot);
     }
 
 public:
     uint32_t action()
     {
-        return proxy_.getProperty("action").onInterface(INTERFACE_NAME);
+        return proxy_->getProperty("action").onInterface(INTERFACE_NAME);
     }
 
     void action(const uint32_t& value)
     {
-        proxy_.setProperty("action").onInterface(INTERFACE_NAME).toValue(value);
+        proxy_->setProperty("action").onInterface(INTERFACE_NAME).toValue(value);
     }
 
     bool blocking()
     {
-        return proxy_.getProperty("blocking").onInterface(INTERFACE_NAME);
+        return proxy_->getProperty("blocking").onInterface(INTERFACE_NAME);
     }
 
     void blocking(const bool& value)
     {
-        proxy_.setProperty("blocking").onInterface(INTERFACE_NAME).toValue(value);
+        proxy_->setProperty("blocking").onInterface(INTERFACE_NAME).toValue(value);
     }
 
     std::string state()
     {
-        return proxy_.getProperty("state").onInterface(INTERFACE_NAME);
+        return proxy_->getProperty("state").onInterface(INTERFACE_NAME);
     }
 
 private:
-    sdbus::IProxy& proxy_;
+    sdbus::IProxy* proxy_;
+    sdbus::Slot simpleSignalSlot_;
 };
 
 }} // namespaces

tests/integrationtests/org.sdbuscpp.integrationtests.xml

@@ -45,7 +45,7 @@
             <arg type="(ix)" direction="in" />
             <arg type="i" direction="out" />
         </method>
-        <method name="sumVectorItems">
+        <method name="sumArrayItems">
             <arg type="aq" direction="in" />
             <arg type="at" direction="in" />
             <arg type="u" direction="out" />
@@ -82,7 +82,7 @@
         </method>
         <method name="emitTwoSimpleSignals">
         </method>
-        
+
         <signal name="simpleSignal">
             <annotation name="org.freedesktop.DBus.Deprecated" value="true" />
         </signal>
@@ -102,4 +102,4 @@
             <annotation name="org.freedesktop.DBus.Property.EmitsChangedSignal" value="const"/>
         </property>
     </interface>
-</node>        
+</node>

tests/perftests/perftests-adaptor.h

@@ -20,19 +20,29 @@ public:
 
 protected:
     perftests_adaptor(sdbus::IObject& object)
-        : object_(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(const perftests_adaptor&) = delete;
+    perftests_adaptor& operator=(const perftests_adaptor&) = delete;
+    perftests_adaptor(perftests_adaptor&&) = default;
+    perftests_adaptor& operator=(perftests_adaptor&&) = default;
+
     ~perftests_adaptor() = default;
 
+    void registerAdaptor()
+    {
+        object_->addVTable( sdbus::registerMethod("sendDataSignals").withInputParamNames("numberOfSignals", "signalMsgSize").implementedAs([this](const uint32_t& numberOfSignals, const uint32_t& signalMsgSize){ return this->sendDataSignals(numberOfSignals, signalMsgSize); })
+                          , sdbus::registerMethod("concatenateTwoStrings").withInputParamNames("string1", "string2").withOutputParamNames("result").implementedAs([this](const std::string& string1, const std::string& string2){ return this->concatenateTwoStrings(string1, string2); })
+                          , sdbus::registerSignal("dataSignal").withParameters<std::string>("data")
+                          ).forInterface(INTERFACE_NAME);
+    }
+
 public:
     void emitDataSignal(const std::string& data)
     {
-        object_.emitSignal("dataSignal").onInterface(INTERFACE_NAME).withArguments(data);
+        object_->emitSignal("dataSignal").onInterface(INTERFACE_NAME).withArguments(data);
     }
 
 private:
@@ -40,7 +50,7 @@ private:
     virtual std::string concatenateTwoStrings(const std::string& string1, const std::string& string2) = 0;
 
 private:
-    sdbus::IObject& object_;
+    sdbus::IObject* object_;
 };
 
 }} // namespaces

tests/perftests/perftests-proxy.h

@@ -20,30 +20,39 @@ public:
 
 protected:
     perftests_proxy(sdbus::IProxy& proxy)
-        : proxy_(proxy)
+        : proxy_(&proxy)
     {
-        proxy_.uponSignal("dataSignal").onInterface(INTERFACE_NAME).call([this](const std::string& data){ this->onDataSignal(data); });
     }
 
+    perftests_proxy(const perftests_proxy&) = delete;
+    perftests_proxy& operator=(const perftests_proxy&) = delete;
+    perftests_proxy(perftests_proxy&&) = default;
+    perftests_proxy& operator=(perftests_proxy&&) = default;
+
     ~perftests_proxy() = default;
 
+    void registerProxy()
+    {
+        proxy_->uponSignal("dataSignal").onInterface(INTERFACE_NAME).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)
     {
-        proxy_.callMethod("sendDataSignals").onInterface(INTERFACE_NAME).withArguments(numberOfSignals, 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);
+        proxy_->callMethod("concatenateTwoStrings").onInterface(INTERFACE_NAME).withArguments(string1, string2).storeResultsTo(result);
         return result;
     }
 
 private:
-    sdbus::IProxy& proxy_;
+    sdbus::IProxy* proxy_;
 };
 
 }} // namespaces

tests/stresstests/celsius-thermometer-adaptor.h

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

tests/stresstests/celsius-thermometer-proxy.h

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

tests/stresstests/concatenator-adaptor.h

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

tests/stresstests/concatenator-proxy.h

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

tests/stresstests/fahrenheit-thermometer-adaptor.h

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

tests/stresstests/fahrenheit-thermometer-proxy.h

@@ -22,22 +22,31 @@ public:
 
 protected:
     thermometer_proxy(sdbus::IProxy& proxy)
-        : proxy_(proxy)
+        : proxy_(&proxy)
     {
     }
 
+    thermometer_proxy(const thermometer_proxy&) = delete;
+    thermometer_proxy& operator=(const thermometer_proxy&) = delete;
+    thermometer_proxy(thermometer_proxy&&) = default;
+    thermometer_proxy& operator=(thermometer_proxy&&) = default;
+
     ~thermometer_proxy() = default;
 
+    void registerProxy()
+    {
+    }
+
 public:
     uint32_t getCurrentTemperature()
     {
         uint32_t result;
-        proxy_.callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
+        proxy_->callMethod("getCurrentTemperature").onInterface(INTERFACE_NAME).storeResultsTo(result);
         return result;
     }
 
 private:
-    sdbus::IProxy& proxy_;
+    sdbus::IProxy* proxy_;
 };
 
 }}}} // namespaces
@@ -55,27 +64,36 @@ public:
 
 protected:
     factory_proxy(sdbus::IProxy& proxy)
-        : proxy_(proxy)
+        : proxy_(&proxy)
     {
     }
 
+    factory_proxy(const factory_proxy&) = delete;
+    factory_proxy& operator=(const factory_proxy&) = delete;
+    factory_proxy(factory_proxy&&) = default;
+    factory_proxy& operator=(factory_proxy&&) = default;
+
     ~factory_proxy() = default;
 
+    void registerProxy()
+    {
+    }
+
 public:
     sdbus::ObjectPath createDelegateObject()
     {
         sdbus::ObjectPath result;
-        proxy_.callMethod("createDelegateObject").onInterface(INTERFACE_NAME).storeResultsTo(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();
+        proxy_->callMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).withArguments(delegate).dontExpectReply();
     }
 
 private:
-    sdbus::IProxy& proxy_;
+    sdbus::IProxy* proxy_;
 };
 
 }}}}} // namespaces

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

@@ -12,7 +12,7 @@
     <allow send_destination="org.sdbuscpp.stresstests.service1"/>
     <allow send_interface="org.sdbuscpp.stresstests.service1"/>
   </policy>
-  
+
   <policy context="default">
     <allow own="org.sdbuscpp.stresstests.service2"/>
     <allow send_destination="org.sdbuscpp.stresstests.service2"/>

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

@@ -309,9 +309,9 @@ public:
     }
 
 private:
-    virtual void onConcatenateReply(const std::string& result, [[maybe_unused]] const sdbus::Error* error) override
+    virtual void onConcatenateReply(const std::string& result, [[maybe_unused]] std::optional<sdbus::Error> error) override
     {
-        assert(error == nullptr);
+        assert(error == std::nullopt);
 
         std::stringstream str(result);
         std::string aString;
@@ -427,8 +427,8 @@ int main(int argc, char *argv[])
                 while (!stopClients)
                 {
                     std::map<std::string, sdbus::Variant> param;
-                    param["key1"] = "sdbus-c++-stress-tests";
-                    param["key2"] = ++localCounter;
+                    param["key1"] = sdbus::Variant{"sdbus-c++-stress-tests"};
+                    param["key2"] = sdbus::Variant{++localCounter};
 
                     concatenator.concatenate(param);
 
@@ -509,6 +509,6 @@ int main(int argc, char *argv[])
 
     exitLogger = true;
     loggerThread.join();
-    
+
     return 0;
 }

tests/unittests/Message_test.cpp

@@ -29,6 +29,7 @@
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <cstdint>
+#include <list>
 
 using ::testing::Eq;
 using ::testing::Gt;
@@ -45,6 +46,82 @@ namespace
     }
 }
 
+namespace sdbus {
+
+    template <typename _ElementType>
+    sdbus::Message& operator<<(sdbus::Message& msg, const std::list<_ElementType>& items)
+    {
+        msg.openContainer(sdbus::signature_of<_ElementType>::str());
+
+        for (const auto& item : items)
+            msg << item;
+
+        msg.closeContainer();
+
+        return msg;
+    }
+
+    template <typename _ElementType>
+    sdbus::Message& operator>>(sdbus::Message& msg, std::list<_ElementType>& items)
+    {
+        if(!msg.enterContainer(sdbus::signature_of<_ElementType>::str()))
+            return msg;
+
+        while (true)
+        {
+            _ElementType elem;
+            if (msg >> elem)
+                items.emplace_back(std::move(elem));
+            else
+                break;
+        }
+
+        msg.clearFlags();
+
+        msg.exitContainer();
+
+        return msg;
+    }
+
+}
+
+template <typename _Element, typename _Allocator>
+struct sdbus::signature_of<std::list<_Element, _Allocator>>
+        : sdbus::signature_of<std::vector<_Element, _Allocator>>
+{};
+
+namespace my {
+
+    struct Struct
+    {
+        int i;
+        std::string s;
+        std::list<double> l;
+    };
+
+    bool operator==(const Struct& lhs, const Struct& rhs)
+    {
+        return lhs.i == rhs.i && lhs.s == rhs.s && lhs.l == rhs.l;
+    }
+
+    sdbus::Message& operator<<(sdbus::Message& msg, const Struct& items)
+    {
+        return msg << sdbus::Struct{std::forward_as_tuple(items.i, items.s, items.l)};
+    }
+
+    sdbus::Message& operator>>(sdbus::Message& msg, Struct& items)
+    {
+        sdbus::Struct s{std::forward_as_tuple(items.i, items.s, items.l)};
+        return msg >> s;
+    }
+
+}
+
+template <>
+struct sdbus::signature_of<my::Struct>
+        : sdbus::signature_of<sdbus::Struct<int, std::string, std::list<double>>>
+{};
+
 /*-------------------------------------*/
 /* --          TEST CASES           -- */
 /*-------------------------------------*/
@@ -116,7 +193,7 @@ TEST(AMessage, CanCarryASimpleInteger)
 {
     auto msg = sdbus::createPlainMessage();
 
-    int dataWritten = 5;
+    const int dataWritten = 5;
 
     msg << dataWritten;
     msg.seal();
@@ -131,7 +208,7 @@ TEST(AMessage, CanCarryAUnixFd)
 {
     auto msg = sdbus::createPlainMessage();
 
-    sdbus::UnixFd dataWritten{0};
+    const sdbus::UnixFd dataWritten{0};
     msg << dataWritten;
 
     msg.seal();
@@ -146,7 +223,7 @@ TEST(AMessage, CanCarryAVariant)
 {
     auto msg = sdbus::createPlainMessage();
 
-    auto dataWritten = sdbus::Variant((double)3.14);
+    const auto dataWritten = sdbus::Variant((double)3.14);
 
     msg << dataWritten;
     msg.seal();
@@ -161,8 +238,8 @@ TEST(AMessage, CanCarryACollectionOfEmbeddedVariants)
 {
     auto msg = sdbus::createPlainMessage();
 
-    auto value = std::vector<sdbus::Variant>{"hello"s, (double)3.14};
-    auto dataWritten = sdbus::Variant{value};
+    std::vector<sdbus::Variant> value{sdbus::Variant{"hello"s}, sdbus::Variant{(double)3.14}};
+    const auto dataWritten = sdbus::Variant{value};
 
     msg << dataWritten;
     msg.seal();
@@ -174,11 +251,11 @@ TEST(AMessage, CanCarryACollectionOfEmbeddedVariants)
     ASSERT_THAT(dataRead.get<decltype(value)>()[1].get<double>(), Eq(value[1].get<double>()));
 }
 
-TEST(AMessage, CanCarryAnArray)
+TEST(AMessage, CanCarryDBusArrayOfTrivialTypesGivenAsStdVector)
 {
     auto msg = sdbus::createPlainMessage();
 
-    std::vector<int64_t> dataWritten{3545342, 43643532, 324325};
+    const std::vector<int64_t> dataWritten{3545342, 43643532, 324325};
 
     msg << dataWritten;
     msg.seal();
@@ -189,6 +266,116 @@ TEST(AMessage, CanCarryAnArray)
     ASSERT_THAT(dataRead, Eq(dataWritten));
 }
 
+TEST(AMessage, CanCarryDBusArrayOfNontrivialTypesGivenAsStdVector)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const std::vector<sdbus::Signature> dataWritten{"s", "u", "b"};
+
+    msg << dataWritten;
+    msg.seal();
+
+    std::vector<sdbus::Signature> dataRead;
+    msg >> dataRead;
+
+    ASSERT_THAT(dataRead, Eq(dataWritten));
+}
+
+TEST(AMessage, CanCarryDBusArrayOfTrivialTypesGivenAsStdArray)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const std::array<int, 3> dataWritten{3545342, 43643532, 324325};
+
+    msg << dataWritten;
+    msg.seal();
+
+    std::array<int, 3> dataRead;
+    msg >> dataRead;
+
+    ASSERT_THAT(dataRead, Eq(dataWritten));
+}
+
+TEST(AMessage, CanCarryDBusArrayOfNontrivialTypesGivenAsStdArray)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const std::array<sdbus::Signature, 3> dataWritten{"s", "u", "b"};
+
+    msg << dataWritten;
+    msg.seal();
+
+    std::array<sdbus::Signature, 3> dataRead;
+    msg >> dataRead;
+
+    ASSERT_THAT(dataRead, Eq(dataWritten));
+}
+
+#if __cplusplus >= 202002L
+TEST(AMessage, CanCarryDBusArrayOfTrivialTypesGivenAsStdSpan)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const std::array<int, 3> sourceArray{3545342, 43643532, 324325};
+    const std::span dataWritten{sourceArray};
+
+    msg << dataWritten;
+    msg.seal();
+
+    std::array<int, 3> destinationArray;
+    std::span dataRead{destinationArray};
+    msg >> dataRead;
+
+    ASSERT_THAT(std::vector(dataRead.begin(), dataRead.end()), Eq(std::vector(dataWritten.begin(), dataWritten.end())));
+}
+
+TEST(AMessage, CanCarryDBusArrayOfNontrivialTypesGivenAsStdSpan)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const std::array<sdbus::Signature, 3> sourceArray{"s", "u", "b"};
+    const std::span dataWritten{sourceArray};
+
+    msg << dataWritten;
+    msg.seal();
+
+    std::array<sdbus::Signature, 3> destinationArray;
+    std::span dataRead{destinationArray};
+    msg >> dataRead;
+
+    ASSERT_THAT(std::vector(dataRead.begin(), dataRead.end()), Eq(std::vector(dataWritten.begin(), dataWritten.end())));
+}
+#endif
+
+TEST(AMessage, ThrowsWhenDestinationStdArrayIsTooSmallDuringDeserialization)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const std::vector<int> dataWritten{3545342, 43643532, 324325, 89789, 15343};
+
+    msg << dataWritten;
+    msg.seal();
+
+    std::array<int, 3> dataRead;
+    ASSERT_THROW(msg >> dataRead, sdbus::Error);
+}
+
+#if __cplusplus >= 202002L
+TEST(AMessage, ThrowsWhenDestinationStdSpanIsTooSmallDuringDeserialization)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const std::array<int, 3> dataWritten{3545342, 43643532, 324325};
+
+    msg << dataWritten;
+    msg.seal();
+
+    std::array<int, 2> destinationArray;
+    std::span dataRead{destinationArray};
+    ASSERT_THROW(msg >> dataRead, sdbus::Error);
+}
+#endif
+
 TEST(AMessage, CanCarryADictionary)
 {
     auto msg = sdbus::createPlainMessage();
@@ -264,3 +451,35 @@ TEST(AMessage, CanPeekContainerContents)
     ASSERT_THAT(type, "a");
     ASSERT_THAT(contents, "{is}");
 }
+
+TEST(AMessage, CanCarryDBusArrayGivenAsCustomType)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const std::list<int64_t> dataWritten{3545342, 43643532, 324325};
+    //custom::MyType t;
+
+    msg << dataWritten;
+    // msg << t;
+    msg.seal();
+
+    std::list<int64_t> dataRead;
+    msg >> dataRead;
+
+    ASSERT_THAT(dataRead, Eq(dataWritten));
+}
+
+TEST(AMessage, CanCarryDBusStructGivenAsCustomType)
+{
+    auto msg = sdbus::createPlainMessage();
+
+    const my::Struct dataWritten{3545342, "hello"s, {3.14, 2.4568546}};
+
+    msg << dataWritten;
+    msg.seal();
+
+    my::Struct dataRead;
+    msg >> dataRead;
+
+    ASSERT_THAT(dataRead, Eq(dataWritten));
+}

tests/unittests/PollData_test.cpp

@@ -0,0 +1,125 @@
+/**
+ * (C) 2016 - 2021 KISTLER INSTRUMENTE AG, Winterthur, Switzerland
+ * (C) 2016 - 2022 Stanislav Angelovic <stanislav.angelovic@protonmail.com>
+ *
+ * @file PollData_test.cpp
+ *
+ * Created on: Jan 19, 2023
+ * 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++/IConnection.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include <chrono>
+
+using ::testing::Eq;
+using ::testing::Ge;
+using ::testing::Le;
+using ::testing::AllOf;
+using namespace std::string_literals;
+using namespace std::chrono_literals;
+
+/*-------------------------------------*/
+/* --          TEST CASES           -- */
+/*-------------------------------------*/
+
+TEST(PollData, ReturnsZeroRelativeTimeoutForZeroAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    pd.timeout = std::chrono::microseconds::zero();
+
+    auto relativeTimeout = pd.getRelativeTimeout();
+
+    EXPECT_THAT(relativeTimeout, Eq(std::chrono::microseconds::zero()));
+}
+
+TEST(PollData, ReturnsZeroPollTimeoutForZeroAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    pd.timeout = std::chrono::microseconds::zero();
+
+    auto pollTimeout = pd.getPollTimeout();
+
+    EXPECT_THAT(pollTimeout, Eq(0));
+}
+
+TEST(PollData, ReturnsInfiniteRelativeTimeoutForInfiniteAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    pd.timeout = std::chrono::microseconds::max();
+
+    auto relativeTimeout = pd.getRelativeTimeout();
+
+    EXPECT_THAT(relativeTimeout, Eq(std::chrono::microseconds::max()));
+}
+
+TEST(PollData, ReturnsNegativePollTimeoutForInfiniteAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    pd.timeout = std::chrono::microseconds::max();
+
+    auto pollTimeout = pd.getPollTimeout();
+
+    EXPECT_THAT(pollTimeout, Eq(-1));
+}
+
+TEST(PollData, ReturnsZeroRelativeTimeoutForPastAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    auto past = std::chrono::steady_clock::now() - 10s;
+    pd.timeout = std::chrono::duration_cast<std::chrono::microseconds>(past.time_since_epoch());
+
+    auto relativeTimeout = pd.getRelativeTimeout();
+
+    EXPECT_THAT(relativeTimeout, Eq(0us));
+}
+
+TEST(PollData, ReturnsZeroPollTimeoutForPastAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    auto past = std::chrono::steady_clock::now() - 10s;
+    pd.timeout = std::chrono::duration_cast<std::chrono::microseconds>(past.time_since_epoch());
+
+    auto pollTimeout = pd.getPollTimeout();
+
+    EXPECT_THAT(pollTimeout, Eq(0));
+}
+
+TEST(PollData, ReturnsCorrectRelativeTimeoutForFutureAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    auto future = std::chrono::steady_clock::now() + 1s;
+    pd.timeout = std::chrono::duration_cast<std::chrono::microseconds>(future.time_since_epoch());
+
+    auto relativeTimeout = pd.getRelativeTimeout();
+
+    EXPECT_THAT(relativeTimeout, AllOf(Ge(900ms), Le(1100ms)));
+}
+
+TEST(PollData, ReturnsCorrectPollTimeoutForFutureAbsoluteTimeout)
+{
+    sdbus::IConnection::PollData pd;
+    auto future = std::chrono::steady_clock::now() + 1s;
+    pd.timeout = std::chrono::duration_cast<std::chrono::microseconds>(future.time_since_epoch());
+
+    auto pollTimeout = pd.getPollTimeout();
+
+    EXPECT_THAT(pollTimeout, AllOf(Ge(900), Le(1100)));
+}

tests/unittests/TypeTraits_test.cpp

@@ -77,7 +77,12 @@ namespace
     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")
+    TYPE(std::array<int16_t, 3>)HAS_DBUS_TYPE_SIGNATURE("an")
+#if __cplusplus >= 202002L
+    TYPE(std::span<int16_t>)HAS_DBUS_TYPE_SIGNATURE("ao")
+#endif
     TYPE(std::map<int32_t, int64_t>)HAS_DBUS_TYPE_SIGNATURE("a{ix}")
+    TYPE(std::unordered_map<int32_t, int64_t>)HAS_DBUS_TYPE_SIGNATURE("a{ix}")
     using ComplexType = std::map<
                             uint64_t,
                             sdbus::Struct<
@@ -86,9 +91,10 @@ namespace
                                     std::vector<
                                         sdbus::Struct<
                                             sdbus::ObjectPath,
+                                            std::array<int16_t, 3>,
                                             bool,
                                             sdbus::Variant,
-                                            std::map<int, std::string>
+                                            std::unordered_map<int, std::string>
                                         >
                                     >
                                 >,
@@ -97,7 +103,7 @@ namespace
                                 const char*
                             >
                         >;
-    TYPE(ComplexType)HAS_DBUS_TYPE_SIGNATURE("a{t(a{ya(obva{is})}ghs)}")
+    TYPE(ComplexType)HAS_DBUS_TYPE_SIGNATURE("a{t(a{ya(oanbva{is})}ghs)}")
 
     typedef ::testing::Types< bool
                             , uint8_t
@@ -117,7 +123,12 @@ namespace
                             , sdbus::Struct<bool>
                             , sdbus::Struct<uint16_t, double, std::string, sdbus::Variant>
                             , std::vector<int16_t>
+                            , std::array<int16_t, 3>
+#if __cplusplus >= 202002L
+                            , std::span<int16_t>
+#endif
                             , std::map<int32_t, int64_t>
+                            , std::unordered_map<int32_t, int64_t>
                             , ComplexType
                             > DBusSupportedTypes;
 

tests/unittests/Types_test.cpp

@@ -67,7 +67,7 @@ TEST(AVariant, CanBeConstructedFromASimpleValue)
 TEST(AVariant, CanBeConstructedFromAComplexValue)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{{"hello"s, ANY_DOUBLE}, {"world"s, ANY_DOUBLE}}} };
 
     ASSERT_NO_THROW(sdbus::Variant{value});
 }
@@ -103,7 +103,7 @@ TEST(ASimpleVariant, ReturnsTheSimpleValueWhenAsked)
 TEST(AComplexVariant, ReturnsTheComplexValueWhenAsked)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{{"hello"s, ANY_DOUBLE}, {"world"s, ANY_DOUBLE}}} };
 
     sdbus::Variant variant(value);
 
@@ -123,7 +123,7 @@ TEST(AVariant, HasConceptuallyNonmutableGetMethodWhichCanBeCalledXTimes)
 TEST(AVariant, ReturnsTrueWhenAskedIfItContainsTheTypeItReallyContains)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{{"hello"s, ANY_DOUBLE}, {"world"s, ANY_DOUBLE}}} };
 
     sdbus::Variant variant(value);
 
@@ -143,8 +143,8 @@ TEST(AVariant, CanContainOtherEmbeddedVariants)
 {
     using TypeWithVariants = std::vector<sdbus::Struct<sdbus::Variant, double>>;
     TypeWithVariants value;
-    value.emplace_back(sdbus::make_struct(sdbus::Variant("a string"), ANY_DOUBLE));
-    value.emplace_back(sdbus::make_struct(sdbus::Variant(ANY_UINT64), ANY_DOUBLE));
+    value.push_back({sdbus::Variant("a string"), ANY_DOUBLE});
+    value.push_back({sdbus::Variant(ANY_UINT64), ANY_DOUBLE});
 
     sdbus::Variant variant(value);
 
@@ -172,7 +172,7 @@ TEST(AnEmptyVariant, ThrowsWhenBeingSerializedToAMessage)
 TEST(ANonEmptyVariant, SerializesToAndDeserializesFromAMessageSuccessfully)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{{"hello"s, ANY_DOUBLE}, {"world"s, ANY_DOUBLE}}} };
     sdbus::Variant variant(value);
 
     auto msg = sdbus::createPlainMessage();
@@ -187,7 +187,7 @@ TEST(ANonEmptyVariant, SerializesToAndDeserializesFromAMessageSuccessfully)
 TEST(CopiesOfVariant, SerializeToAndDeserializeFromMessageSuccessfully)
 {
     using ComplexType = std::map<uint64_t, std::vector<sdbus::Struct<std::string, double>>>;
-    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{sdbus::make_struct("hello"s, ANY_DOUBLE), sdbus::make_struct("world"s, ANY_DOUBLE)}} };
+    ComplexType value{ {ANY_UINT64, ComplexType::mapped_type{{"hello"s, ANY_DOUBLE}, {"world"s, ANY_DOUBLE}}} };
     sdbus::Variant variant(value);
     auto variantCopy1{variant};
     auto variantCopy2 = variant;
@@ -207,15 +207,41 @@ TEST(CopiesOfVariant, SerializeToAndDeserializeFromMessageSuccessfully)
     ASSERT_THAT(receivedVariant3.get<decltype(value)>(), Eq(value));
 }
 
-TEST(AStruct, CreatesStructFromTuple)
+TEST(AStruct, CanBeCreatedFromStdTuple)
 {
     std::tuple<int32_t, std::string> value{1234, "abcd"};
-    sdbus::Struct<int32_t, std::string> valueStruct{value};
+    sdbus::Struct valueStruct{value};
+
+    ASSERT_THAT(valueStruct.get<0>(), Eq(std::get<0>(value)));
+    ASSERT_THAT(valueStruct.get<1>(), Eq(std::get<1>(value)));
+}
+
+TEST(AStruct, CanProvideItsDataThroughStdGet)
+{
+    std::tuple<int32_t, std::string> value{1234, "abcd"};
+    sdbus::Struct valueStruct{value};
 
     ASSERT_THAT(std::get<0>(valueStruct), Eq(std::get<0>(value)));
     ASSERT_THAT(std::get<1>(valueStruct), Eq(std::get<1>(value)));
 }
 
+TEST(AStruct, CanBeUsedLikeStdTupleType)
+{
+    using StructType = sdbus::Struct<int, std::string, bool>;
+
+    static_assert(std::tuple_size_v<StructType> == 3);
+    static_assert(std::is_same_v<std::tuple_element_t<1, StructType>, std::string>);
+}
+
+TEST(AStruct, CanBeUsedInStructuredBinding)
+{
+    sdbus::Struct valueStruct(1234, "abcd", true);
+
+    auto [first, second, third] = valueStruct;
+
+    ASSERT_THAT(std::tie(first, second, third), Eq(std::tuple{1234, "abcd", true}));
+}
+
 TEST(AnObjectPath, CanBeConstructedFromCString)
 {
     const char* aPath = "/some/path";

tests/unittests/mocks/SdBusMock.h

@@ -62,20 +62,26 @@ public:
     MOCK_METHOD1(sd_bus_open_user, int(sd_bus **ret));
     MOCK_METHOD2(sd_bus_open_user_with_address, int(sd_bus **ret, const char* address));
     MOCK_METHOD2(sd_bus_open_system_remote, int(sd_bus **ret, const char *host));
+    MOCK_METHOD2(sd_bus_open_direct, int(sd_bus **ret, const char* address));
+    MOCK_METHOD2(sd_bus_open_direct, int(sd_bus **ret, int fd));
+    MOCK_METHOD2(sd_bus_open_server, int(sd_bus **ret, int fd));
     MOCK_METHOD3(sd_bus_request_name, int(sd_bus *bus, const char *name, uint64_t flags));
     MOCK_METHOD2(sd_bus_release_name, int(sd_bus *bus, const char *name));
     MOCK_METHOD2(sd_bus_get_unique_name, int(sd_bus *bus, const char **name));
     MOCK_METHOD6(sd_bus_add_object_vtable, int(sd_bus *bus, sd_bus_slot **slot, const char *path, const char *interface, const sd_bus_vtable *vtable, void *userdata));
     MOCK_METHOD3(sd_bus_add_object_manager, int(sd_bus *bus, sd_bus_slot **slot, const char *path));
     MOCK_METHOD5(sd_bus_add_match, int(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, void *userdata));
+    MOCK_METHOD6(sd_bus_add_match_async, int(sd_bus *bus, sd_bus_slot **slot, const char *match, sd_bus_message_handler_t callback, sd_bus_message_handler_t install_callback, void *userdata));
+    MOCK_METHOD8(sd_bus_match_signal, int(sd_bus *bus, sd_bus_slot **ret, const char *sender, const char *path, const char *interface, const char *member, sd_bus_message_handler_t callback, void *userdata));
     MOCK_METHOD1(sd_bus_slot_unref, sd_bus_slot*(sd_bus_slot *slot));
 
     MOCK_METHOD1(sd_bus_new, int(sd_bus **ret));
     MOCK_METHOD1(sd_bus_start, int(sd_bus *bus));
 
     MOCK_METHOD2(sd_bus_process, int(sd_bus *bus, sd_bus_message **r));
+    MOCK_METHOD1(sd_bus_get_current_message, sd_bus_message*(sd_bus *bus));
     MOCK_METHOD2(sd_bus_get_poll_data, int(sd_bus *bus, PollData* data));
-
+    MOCK_METHOD2(sd_bus_get_n_queued_read, int(sd_bus *bus, uint64_t *ret));
     MOCK_METHOD1(sd_bus_flush, int(sd_bus *bus));
     MOCK_METHOD1(sd_bus_flush_close_unref, sd_bus *(sd_bus *bus));
     MOCK_METHOD1(sd_bus_close_unref, sd_bus *(sd_bus *bus));

tools/CMakeLists.txt

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

tools/xml2cpp-codegen/AdaptorGenerator.cpp

@@ -85,7 +85,17 @@ std::string AdaptorGenerator::processInterface(Node& interface) const
             << tab << "static constexpr const char* INTERFACE_NAME = \"" << ifaceName << "\";" << endl << endl
             << "protected:" << endl
             << tab << className << "(sdbus::IObject& object)" << endl
-            << tab << tab << ": object_(object)" << endl;
+            << tab << tab << ": object_(&object)" << endl
+            << tab << "{" << endl
+            << tab << "}" << endl << endl;
+
+    // Rule of Five
+    body << tab << className << "(const " << className << "&) = delete;" << endl;
+    body << tab << className << "& operator=(const " << className << "&) = delete;" << endl;
+    body << tab << className << "(" << className << "&&) = default;" << endl;
+    body << tab << className << "& operator=(" << className << "&&) = default;" << endl << endl;
+
+    body << tab << "~" << className << "() = default;" << endl << endl;
 
     Nodes methods = interface["method"];
     Nodes signals = interface["signal"];
@@ -111,28 +121,29 @@ std::string AdaptorGenerator::processInterface(Node& interface) const
     if(!annotationRegistration.empty())
     {
         std::stringstream str;
-        str << tab << tab << "object_.setInterfaceFlags(INTERFACE_NAME)" << annotationRegistration << ";" << endl;
+        str << "sdbus::setInterfaceFlags()" << annotationRegistration << ";";
         annotationRegistration = str.str();
     }
 
-    std::string methodRegistration, methodDeclaration;
-    std::tie(methodRegistration, methodDeclaration) = processMethods(methods);
+    std::vector<std::string> methodRegistrations;
+    std::string methodDeclaration;
+    std::tie(methodRegistrations, methodDeclaration) = processMethods(methods);
 
-    std::string signalRegistration, signalMethods;
-    std::tie(signalRegistration, signalMethods) = processSignals(signals);
+    std::vector<std::string> signalRegistrations;
+    std::string signalMethods;
+    std::tie(signalRegistrations, signalMethods) = processSignals(signals);
 
-    std::string propertyRegistration, propertyAccessorDeclaration;
-    std::tie(propertyRegistration, propertyAccessorDeclaration) = processProperties(properties);
+    std::vector<std::string> propertyRegistrations;
+    std::string propertyAccessorDeclaration;
+    std::tie(propertyRegistrations, propertyAccessorDeclaration) = processProperties(properties);
 
-    body << tab << "{" << endl
-                       << annotationRegistration
-                       << methodRegistration
-                       << signalRegistration
-                       << propertyRegistration
+    auto vtableRegistration = createVTableRegistration(annotationRegistration, methodRegistrations, signalRegistrations, propertyRegistrations);
+
+    body << tab << "void registerAdaptor()" << endl
+         << tab << "{" << endl
+                       << vtableRegistration << endl
          << tab << "}" << endl << endl;
 
-    body << tab << "~" << className << "() = default;" << endl << endl;
-
     if (!signalMethods.empty())
     {
         body << "public:" << endl << signalMethods;
@@ -149,7 +160,7 @@ std::string AdaptorGenerator::processInterface(Node& interface) const
     }
 
     body << "private:" << endl
-            << tab << "sdbus::IObject& object_;" << endl
+            << tab << "sdbus::IObject* object_;" << endl
             << "};" << endl << endl
             << std::string(namespacesCount, '}') << " // namespaces" << endl << endl;
 
@@ -157,12 +168,16 @@ std::string AdaptorGenerator::processInterface(Node& interface) const
 }
 
 
-std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Nodes& methods) const
+std::tuple<std::vector<std::string>, std::string> AdaptorGenerator::processMethods(const Nodes& methods) const
 {
-    std::ostringstream registrationSS, declarationSS;
+    std::ostringstream declarationSS;
+
+    std::vector<std::string> methodRegistrations;
 
     for (const auto& method : methods)
     {
+        std::ostringstream registrationSS;
+
         auto methodName = method->get("name");
         auto methodNameSafe = mangle_name(methodName);
 
@@ -186,7 +201,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
             }
             else if (annotationName == "org.freedesktop.DBus.Method.Async")
             {
-                if (annotationValue == "server" || annotationValue == "clientserver")
+                if (annotationValue == "server" || annotationValue == "clientserver" || annotationValue == "client-server")
                     async = true;
             }
             else if (annotationName == "org.freedesktop.systemd1.Privileged")
@@ -211,9 +226,8 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
 
         using namespace std::string_literals;
 
-        registrationSS << tab << tab << "object_.registerMethod(\""
+        registrationSS << "sdbus::registerMethod(\""
                 << methodName << "\")"
-                << ".onInterface(INTERFACE_NAME)"
                 << (!argStringsStr.empty() ? (".withInputParamNames(" + argStringsStr + ")") : "")
                 << (!outArgStringsStr.empty() ? (".withOutputParamNames(" + outArgStringsStr + ")") : "")
                 << ".implementedAs("
@@ -223,7 +237,9 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
                 << "){ " << (async ? "" : "return ") << "this->" << methodNameSafe << "("
                 << (async ? "std::move(result)"s + (argTypeStr.empty() ? "" : ", ") : "")
                 << argStr << "); })"
-                << annotationRegistration << ";" << endl;
+                << annotationRegistration;
+
+        methodRegistrations.push_back(registrationSS.str());
 
         declarationSS << tab
                 << "virtual "
@@ -235,16 +251,20 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
                 << ") = 0;" << endl;
     }
 
-    return std::make_tuple(registrationSS.str(), declarationSS.str());
+    return std::make_tuple(methodRegistrations, declarationSS.str());
 }
 
 
-std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Nodes& signals) const
+std::tuple<std::vector<std::string>, std::string> AdaptorGenerator::processSignals(const Nodes& signals) const
 {
-    std::ostringstream signalRegistrationSS, signalMethodSS;
+    std::ostringstream signalMethodSS;
+
+    std::vector<std::string> signalRegistrations;
 
     for (const auto& signal : signals)
     {
+        std::stringstream signalRegistrationSS;
+
         auto name = signal->get("name");
 
         auto annotations = getAnnotations(*signal);
@@ -266,9 +286,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
         std::string argStr, argTypeStr, typeStr, argStringsStr;
         std::tie(argStr, argTypeStr, typeStr, argStringsStr) = argsToNamesAndTypes(args);
 
-        signalRegistrationSS << tab << tab
-                << "object_.registerSignal(\"" << name << "\")"
-                        ".onInterface(INTERFACE_NAME)";
+        signalRegistrationSS << "sdbus::registerSignal(\"" << name << "\")";
 
         if (args.size() > 0)
         {
@@ -276,7 +294,8 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
         }
 
         signalRegistrationSS << annotationRegistration;
-        signalRegistrationSS << ";" << endl;
+
+        signalRegistrations.push_back(signalRegistrationSS.str());
 
         auto nameWithCapFirstLetter = name;
         nameWithCapFirstLetter[0] = std::toupper(nameWithCapFirstLetter[0]);
@@ -284,7 +303,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
 
         signalMethodSS << tab << "void emit" << nameWithCapFirstLetter << "(" << argTypeStr << ")" << endl
                 << tab << "{" << endl
-                << tab << tab << "object_.emitSignal(\"" << name << "\")"
+                << tab << tab << "object_->emitSignal(\"" << name << "\")"
                         ".onInterface(INTERFACE_NAME)";
 
         if (!argStr.empty())
@@ -296,16 +315,20 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
                 << tab << "}" << endl << endl;
     }
 
-    return std::make_tuple(signalRegistrationSS.str(), signalMethodSS.str());
+    return std::make_tuple(signalRegistrations, signalMethodSS.str());
 }
 
 
-std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const Nodes& properties) const
+std::tuple<std::vector<std::string>, std::string> AdaptorGenerator::processProperties(const Nodes& properties) const
 {
-    std::ostringstream registrationSS, declarationSS;
+    std::ostringstream declarationSS;
+
+    std::vector<std::string> propertyRegistrations;
 
     for (const auto& property : properties)
     {
+        std::ostringstream registrationSS;
+
         auto propertyName = property->get("name");
         auto propertyNameSafe = mangle_name(propertyName);
         auto propertyAccess = property->get("access");
@@ -333,9 +356,8 @@ std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const N
                           << "Option '" << annotationName << "' not allowed or supported in this context! Option ignored..." << std::endl;
         }
 
-        registrationSS << tab << tab << "object_.registerProperty(\""
-                << propertyName << "\")"
-                << ".onInterface(INTERFACE_NAME)";
+        registrationSS << "sdbus::registerProperty(\""
+                << propertyName << "\")";
 
         if (propertyAccess == "read" || propertyAccess == "readwrite")
         {
@@ -350,7 +372,8 @@ std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const N
         }
 
         registrationSS << annotationRegistration;
-        registrationSS << ";" << endl;
+
+        propertyRegistrations.push_back(registrationSS.str());
 
         if (propertyAccess == "read" || propertyAccess == "readwrite")
             declarationSS << tab << "virtual " << propertyType << " " << propertyNameSafe << "() = 0;" << endl;
@@ -358,7 +381,38 @@ std::tuple<std::string, std::string> AdaptorGenerator::processProperties(const N
             declarationSS << tab << "virtual void " << propertyNameSafe << "(" << propertyTypeArg << ") = 0;" << endl;
     }
 
-    return std::make_tuple(registrationSS.str(), declarationSS.str());
+    return std::make_tuple(propertyRegistrations, declarationSS.str());
+}
+
+std::string AdaptorGenerator::createVTableRegistration(const std::string& annotationRegistration,
+                                                       const std::vector<std::string>& methodRegistrations,
+                                                       const std::vector<std::string>& signalRegistrations,
+                                                       const std::vector<std::string>& propertyRegistrations) const
+{
+    std::vector<std::string> allRegistrations;
+    if (!annotationRegistration.empty())
+        allRegistrations.push_back(annotationRegistration);
+    allRegistrations.insert(allRegistrations.end(), methodRegistrations.begin(), methodRegistrations.end());
+    allRegistrations.insert(allRegistrations.end(), signalRegistrations.begin(), signalRegistrations.end());
+    allRegistrations.insert(allRegistrations.end(), propertyRegistrations.begin(), propertyRegistrations.end());
+
+    if (allRegistrations.empty())
+        return {};
+
+    std::ostringstream registrationSS;
+    if (allRegistrations.size() == 1)
+    {
+        registrationSS << tab << tab << "object_->addVTable(" << allRegistrations[0] << ").forInterface(INTERFACE_NAME);";
+    }
+    else
+    {
+        registrationSS     << tab << tab << "object_->addVTable( " << allRegistrations[0] << endl;
+        for (size_t i = 1; i < allRegistrations.size(); ++i)
+            registrationSS << tab << tab << "                  , " << allRegistrations[i] << endl;
+        registrationSS     << tab << tab << "                  ).forInterface(INTERFACE_NAME);";
+    }
+
+    return registrationSS.str();
 }
 
 std::map<std::string, std::string> AdaptorGenerator::getAnnotations( sdbuscpp::xml::Node& node) const

tools/xml2cpp-codegen/AdaptorGenerator.h

@@ -59,21 +59,26 @@ private:
      * @param methods
      * @return tuple: registration of methods, declaration of abstract methods
      */
-    std::tuple<std::string, std::string> processMethods(const sdbuscpp::xml::Nodes& methods) const;
+    std::tuple<std::vector<std::string>, std::string> processMethods(const sdbuscpp::xml::Nodes& methods) const;
 
     /**
      * Generate source code for signals
      * @param signals
      * @return tuple: registration of signals, definition of signal methods
      */
-    std::tuple<std::string, std::string> processSignals(const sdbuscpp::xml::Nodes& signals) const;
+    std::tuple<std::vector<std::string>, std::string> processSignals(const sdbuscpp::xml::Nodes& signals) const;
 
     /**
      * Generate source code for properties
      * @param properties
      * @return tuple: registration of properties, declaration of property accessor virtual methods
      */
-    std::tuple<std::string, std::string> processProperties(const sdbuscpp::xml::Nodes& properties) const;
+    std::tuple<std::vector<std::string>, std::string> processProperties(const sdbuscpp::xml::Nodes& properties) const;
+
+    std::string createVTableRegistration(const std::string& annotationRegistration,
+                                         const std::vector<std::string>& methodRegistrations,
+                                         const std::vector<std::string>& signalRegistrations,
+                                         const std::vector<std::string>& propertyRegistrations) const;
 
     /**
      * Get annotations listed for a given node

tools/xml2cpp-codegen/ProxyGenerator.cpp

@@ -84,7 +84,17 @@ std::string ProxyGenerator::processInterface(Node& interface) const
             << tab << "static constexpr const char* INTERFACE_NAME = \"" << ifaceName << "\";" << endl << endl
             << "protected:" << endl
             << tab << className << "(sdbus::IProxy& proxy)" << endl
-            << tab << tab << ": proxy_(proxy)" << endl;
+            << tab << tab << ": proxy_(&proxy)" << endl
+            << tab << "{" << endl
+            << tab << "}" << endl << endl;
+
+    // Rule of Five
+    body << tab << className << "(const " << className << "&) = delete;" << endl;
+    body << tab << className << "& operator=(const " << className << "&) = delete;" << endl;
+    body << tab << className << "(" << className << "&&) = default;" << endl;
+    body << tab << className << "& operator=(" << className << "&&) = default;" << endl << endl;
+
+    body << tab << "~" << className << "() = default;" << endl << endl;
 
     Nodes methods = interface["method"];
     Nodes signals = interface["signal"];
@@ -93,21 +103,26 @@ std::string ProxyGenerator::processInterface(Node& interface) const
     std::string registration, declaration;
     std::tie(registration, declaration) = processSignals(signals);
 
-    body << tab << "{" << endl
-            << registration
-            << tab << "}" << endl << endl;
-
-    body << tab << "~" << className << "() = default;" << endl << endl;
+    body << tab << "void registerProxy()" << endl
+         << tab << "{" << endl
+         << registration
+         << tab << "}" << endl << endl;
 
     if (!declaration.empty())
         body << declaration << endl;
 
-    std::string methodDefinitions, asyncDeclarations;
-    std::tie(methodDefinitions, asyncDeclarations) = processMethods(methods);
+    std::string methodDefinitions, asyncDeclarationsMethods;
+    std::tie(methodDefinitions, asyncDeclarationsMethods) = processMethods(methods);
+    std::string propertyDefinitions, asyncDeclarationsProperties;
+    std::tie(propertyDefinitions, asyncDeclarationsProperties) = processProperties(properties);
 
-    if (!asyncDeclarations.empty())
+    if (!asyncDeclarationsMethods.empty())
     {
-        body << asyncDeclarations << endl;
+        body << asyncDeclarationsMethods << endl;
+    }
+    if (!asyncDeclarationsProperties.empty())
+    {
+        body << asyncDeclarationsProperties << endl;
     }
 
     if (!methodDefinitions.empty())
@@ -115,14 +130,13 @@ std::string ProxyGenerator::processInterface(Node& interface) const
         body << "public:" << endl << methodDefinitions;
     }
 
-    std::string propertyDefinitions = processProperties(properties);
     if (!propertyDefinitions.empty())
     {
         body << "public:" << endl << propertyDefinitions;
     }
 
     body << "private:" << endl
-            << tab << "sdbus::IProxy& proxy_;" << endl
+            << tab << "sdbus::IProxy* proxy_;" << endl
             << "};" << endl << endl
             << std::string(namespacesCount, '}') << " // namespaces" << endl << endl;
 
@@ -145,19 +159,30 @@ std::tuple<std::string, std::string> ProxyGenerator::processMethods(const Nodes&
 
         bool dontExpectReply{false};
         bool async{false};
+        bool future{false}; // Async methods implemented by means of either std::future or callbacks
         std::string timeoutValue;
         std::smatch smTimeout;
 
         Nodes annotations = (*method)["annotation"];
         for (const auto& annotation : annotations)
         {
-            if (annotation->get("name") == "org.freedesktop.DBus.Method.NoReply" && annotation->get("value") == "true")
+            const auto annotationName = annotation->get("name");
+            const auto annotationValue = annotation->get("value");
+
+            if (annotationName == "org.freedesktop.DBus.Method.NoReply" && annotationValue == "true")
                 dontExpectReply = true;
-            else if (annotation->get("name") == "org.freedesktop.DBus.Method.Async"
-                     && (annotation->get("value") == "client" || annotation->get("value") == "clientserver"))
-                async = true;
-            if (annotation->get("name") == "org.freedesktop.DBus.Method.Timeout")
-                timeoutValue = annotation->get("value");
+            else
+            {
+                if (annotationName == "org.freedesktop.DBus.Method.Async"
+                     && (annotationValue == "client" || annotationValue == "clientserver" || annotationValue == "client-server"))
+                    async = true;
+                else if (annotationName == "org.freedesktop.DBus.Method.Async.ClientImpl" && annotationValue == "callback")
+                    future = false;
+                else if (annotationName == "org.freedesktop.DBus.Method.Async.ClientImpl" && (annotationValue == "future" || annotationValue == "std::future"))
+                    future = true;
+            }
+            if (annotationName == "org.freedesktop.DBus.Method.Timeout")
+                timeoutValue = annotationValue;
         }
         if (dontExpectReply && outArgs.size() > 0)
         {
@@ -180,12 +205,13 @@ std::tuple<std::string, std::string> ProxyGenerator::processMethods(const Nodes&
         }
 
         auto retType = outArgsToType(outArgs);
+        auto retTypeBare = outArgsToType(outArgs, true);
         std::string inArgStr, inArgTypeStr;
         std::tie(inArgStr, inArgTypeStr, std::ignore, std::ignore) = argsToNamesAndTypes(inArgs);
         std::string outArgStr, outArgTypeStr;
         std::tie(outArgStr, outArgTypeStr, std::ignore, std::ignore) = argsToNamesAndTypes(outArgs);
 
-        const std::string realRetType = (async && !dontExpectReply ? "sdbus::PendingAsyncCall" : async ? "void" : retType);
+        const std::string realRetType = (async && !dontExpectReply ? (future ? "std::future<" + retType + ">" : "sdbus::PendingAsyncCall") : async ? "void" : retType);
         definitionSS << tab << realRetType << " " << nameSafe << "(" << inArgTypeStr << ")" << endl
                 << tab << "{" << endl;
 
@@ -200,7 +226,7 @@ std::tuple<std::string, std::string> ProxyGenerator::processMethods(const Nodes&
         }
 
         definitionSS << tab << tab << (async && !dontExpectReply ? "return " : "")
-                     << "proxy_.callMethod" << (async ? "Async" : "") << "(\"" << name << "\").onInterface(INTERFACE_NAME)";
+                     << "proxy_->callMethod" << (async ? "Async" : "") << "(\"" << name << "\").onInterface(INTERFACE_NAME)";
 
         if (!timeoutValue.empty())
         {
@@ -219,11 +245,18 @@ std::tuple<std::string, std::string> ProxyGenerator::processMethods(const Nodes&
             auto nameBigFirst = name;
             nameBigFirst[0] = islower(nameBigFirst[0]) ? nameBigFirst[0] + 'A' - 'a' : nameBigFirst[0];
 
-            definitionSS << ".uponReplyInvoke([this](const sdbus::Error* error" << (outArgTypeStr.empty() ? "" : ", ") << outArgTypeStr << ")"
-                                             "{ this->on" << nameBigFirst << "Reply(" << outArgStr << (outArgStr.empty() ? "" : ", ") << "error); })";
+            if (future) // Async methods implemented through future
+            {
+                definitionSS << ".getResultAsFuture<" << retTypeBare << ">()";
+            }
+            else // Async methods implemented through callbacks
+            {
+                definitionSS << ".uponReplyInvoke([this](std::optional<sdbus::Error> error" << (outArgTypeStr.empty() ? "" : ", ") << outArgTypeStr << ")"
+                                                 "{ this->on" << nameBigFirst << "Reply(" << outArgStr << (outArgStr.empty() ? "" : ", ") << "std::move(error)); })";
 
-            asyncDeclarationSS << tab << "virtual void on" << nameBigFirst << "Reply("
-                               << outArgTypeStr << (outArgTypeStr.empty() ? "" : ", ")  << "const sdbus::Error* error) = 0;" << endl;
+                asyncDeclarationSS << tab << "virtual void on" << nameBigFirst << "Reply("
+                                   << outArgTypeStr << (outArgTypeStr.empty() ? "" : ", ")  << "std::optional<sdbus::Error> error) = 0;" << endl;
+            }
         }
         else if (outArgs.size() > 0)
         {
@@ -257,7 +290,7 @@ std::tuple<std::string, std::string> ProxyGenerator::processSignals(const Nodes&
         std::tie(argStr, argTypeStr, std::ignore, std::ignore) = argsToNamesAndTypes(args);
 
         registrationSS << tab << tab << "proxy_"
-                ".uponSignal(\"" << name << "\")"
+                "->uponSignal(\"" << name << "\")"
                 ".onInterface(INTERFACE_NAME)"
                 ".call([this](" << argTypeStr << ")"
                 "{ this->on" << nameBigFirst << "(" << argStr << "); });" << endl;
@@ -268,9 +301,9 @@ std::tuple<std::string, std::string> ProxyGenerator::processSignals(const Nodes&
     return std::make_tuple(registrationSS.str(), declarationSS.str());
 }
 
-std::string ProxyGenerator::processProperties(const Nodes& properties) const
+std::tuple<std::string, std::string> ProxyGenerator::processProperties(const Nodes& properties) const
 {
-    std::ostringstream propertySS;
+    std::ostringstream propertySS, asyncDeclarationSS;
     for (const auto& property : properties)
     {
         auto propertyName = property->get("name");
@@ -282,25 +315,93 @@ std::string ProxyGenerator::processProperties(const Nodes& properties) const
         auto propertyArg = std::string("value");
         auto propertyTypeArg = std::string("const ") + propertyType + "& " + propertyArg;
 
+        bool asyncGet{false};
+        bool futureGet{false}; // Async property getter implemented by means of either std::future or callbacks
+        bool asyncSet{false};
+        bool futureSet{false}; // Async property setter implemented by means of either std::future or callbacks
+
+        Nodes annotations = (*property)["annotation"];
+        for (const auto& annotation : annotations)
+        {
+            const auto annotationName = annotation->get("name");
+            const auto annotationValue = annotation->get("value");
+
+            if (annotationName == "org.freedesktop.DBus.Property.Get.Async" && annotationValue == "client") // Server-side not supported (may be in the future)
+                asyncGet = true;
+            else if (annotationName == "org.freedesktop.DBus.Property.Get.Async.ClientImpl" && annotationValue == "callback")
+                futureGet = false;
+            else if (annotationName == "org.freedesktop.DBus.Property.Get.Async.ClientImpl" && (annotationValue == "future" || annotationValue == "std::future"))
+                futureGet = true;
+            else if (annotationName == "org.freedesktop.DBus.Property.Set.Async" && annotationValue == "client") // Server-side not supported (may be in the future)
+                asyncSet = true;
+            else if (annotationName == "org.freedesktop.DBus.Property.Set.Async.ClientImpl" && annotationValue == "callback")
+                futureSet = false;
+            else if (annotationName == "org.freedesktop.DBus.Property.Set.Async.ClientImpl" && (annotationValue == "future" || annotationValue == "std::future"))
+                futureSet = true;
+        }
+
         if (propertyAccess == "read" || propertyAccess == "readwrite")
         {
-            propertySS << tab << propertyType << " " << propertyNameSafe << "()" << endl
+            const std::string realRetType = (asyncGet ? (futureGet ? "std::future<sdbus::Variant>" : "sdbus::PendingAsyncCall") : propertyType);
+
+            propertySS << tab << realRetType << " " << propertyNameSafe << "()" << endl
                     << tab << "{" << endl;
-            propertySS << tab << tab << "return proxy_.getProperty(\"" << propertyName << "\")"
+            propertySS << tab << tab << "return proxy_->getProperty" << (asyncGet ? "Async" : "") << "(\"" << propertyName << "\")"
                             ".onInterface(INTERFACE_NAME)";
+            if (asyncGet)
+            {
+                auto nameBigFirst = propertyName;
+                nameBigFirst[0] = islower(nameBigFirst[0]) ? nameBigFirst[0] + 'A' - 'a' : nameBigFirst[0];
+
+                if (futureGet) // Async methods implemented through future
+                {
+                    propertySS << ".getResultAsFuture()";
+                }
+                else // Async methods implemented through callbacks
+                {
+                    propertySS << ".uponReplyInvoke([this](std::optional<sdbus::Error> error, const sdbus::Variant& value)"
+                                                   "{ this->on" << nameBigFirst << "PropertyGetReply(value.get<" << propertyType << ">(), std::move(error)); })";
+
+                    asyncDeclarationSS << tab << "virtual void on" << nameBigFirst << "PropertyGetReply("
+                                       << "const " << propertyType << "& value, std::optional<sdbus::Error> error) = 0;" << endl;
+                }
+            }
             propertySS << ";" << endl << tab << "}" << endl << endl;
         }
 
         if (propertyAccess == "readwrite" || propertyAccess == "write")
         {
-            propertySS << tab << "void " << propertyNameSafe << "(" << propertyTypeArg << ")" << endl
-                    << tab << "{" << endl;
-            propertySS << tab << tab << "proxy_.setProperty(\"" << propertyName << "\")"
+            const std::string realRetType = (asyncSet ? (futureSet ? "std::future<void>" : "sdbus::PendingAsyncCall") : "void");
+
+            propertySS << tab << realRetType << " " << propertyNameSafe << "(" << propertyTypeArg << ")" << endl
+                       << tab << "{" << endl;
+            propertySS << tab << tab << (asyncSet ? "return " : "") << "proxy_->setProperty" << (asyncSet ? "Async" : "")
+                       << "(\"" << propertyName << "\")"
                             ".onInterface(INTERFACE_NAME)"
                             ".toValue(" << propertyArg << ")";
+
+            if (asyncSet)
+            {
+                auto nameBigFirst = propertyName;
+                nameBigFirst[0] = islower(nameBigFirst[0]) ? nameBigFirst[0] + 'A' - 'a' : nameBigFirst[0];
+
+                if (futureSet) // Async methods implemented through future
+                {
+                    propertySS << ".getResultAsFuture()";
+                }
+                else // Async methods implemented through callbacks
+                {
+                    propertySS << ".uponReplyInvoke([this](std::optional<sdbus::Error> error)"
+                                  "{ this->on" << nameBigFirst << "PropertySetReply(std::move(error)); })";
+
+                    asyncDeclarationSS << tab << "virtual void on" << nameBigFirst << "PropertySetReply("
+                                       << "std::optional<sdbus::Error> error) = 0;" << endl;
+                }
+            }
+
             propertySS << ";" << endl << tab << "}" << endl << endl;
         }
     }
 
-    return propertySS.str();
+    return std::make_tuple(propertySS.str(), asyncDeclarationSS.str());
 }

tools/xml2cpp-codegen/ProxyGenerator.h

@@ -73,7 +73,7 @@ private:
      * @param properties
      * @return source code
      */
-    std::string processProperties(const sdbuscpp::xml::Nodes& properties) const;
+    std::tuple<std::string, std::string> processProperties(const sdbuscpp::xml::Nodes& properties) const;
 
 };
 

tools/xml2cpp-codegen/generator_utils.cpp

@@ -87,7 +87,7 @@ static void _parse_signature(const std::string &signature, std::string &type, un
                     }
                     case '\0':
                     {
-                        std::cerr << 
+                        std::cerr <<
                             "Invalid array definition. Type is missing after '" << signature
                             << "'."
                             << std::endl;