fix(ci): rename cmake parameters

docs: add v2 migration notes to the tutorial
refactor: rename connection creation methods (#406 )
2024-02-16 19:05:37 +01:00 · 2024-02-16 18:59:19 +01:00 · 2024-02-16 18:57:51 +01:00 · 2024-02-16 09:28:16 +01:00 · 2024-02-16 09:27:45 +01:00 · 2024-02-10 20:30:22 +01:00
76 changed files with 3173 additions and 2740 deletions
@@ -4,7 +4,9 @@ on:
  push:
    branches: [ master ]
  pull_request:
-    branches: [ master ]
+    branches:
+      - master
+      - release/v2.0

 jobs:
  build:
@@ -16,9 +18,12 @@ jobs:
        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@v3
    - name: install-libsystemd-toolchain
@@ -40,27 +45,37 @@ jobs:
        sudo update-alternatives --remove-all c++
        sudo update-alternatives --install /usr/bin/c++ c++ /usr/bin/clang++ 10
    - name: install-googletest
-      if: matrix.os == 'ubuntu-22.04' # On older ubuntus the libgmock-dev package is either unavailable or has faulty pkg-config file
+      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 ..
+        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=Debug -DCMAKE_INSTALL_PREFIX:PATH=/usr -DCMAKE_CXX_FLAGS="-O0 -g -W -Wextra -Wall -Wnon-virtual-dtor -Werror" -DCMAKE_VERBOSE_MAKEFILE=ON -DBUILD_TESTS=ON -DINSTALL_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 -DBUILD_TESTS=ON -DINSTALL_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON -DBUILD_CODE_GEN=ON ..
+        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 -DCMAKE_INSTALL_PREFIX:PATH=/usr -DCMAKE_VERBOSE_MAKEFILE=ON -DBUILD_TESTS=ON -DINSTALL_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
@@ -97,7 +112,7 @@ jobs:
        prepare: |
          pkg install -y cmake ninja pkgconf basu expat googletest
        run: |
-          cmake -B _build -G Ninja -DBUILD_CODE_GEN=ON -DBUILD_TESTS=ON -DINSTALL_TESTS=ON -DENABLE_PERF_TESTS=ON -DENABLE_STRESS_TESTS=ON
+          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
@@ -2,12 +2,71 @@
 # PROJECT INFORMATION
 #-------------------------------

-cmake_minimum_required(VERSION 3.13)
+cmake_minimum_required(VERSION 3.14)

-project(sdbus-c++ VERSION 1.4.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
 #-------------------------------
@@ -15,14 +74,12 @@ include(GNUInstallDirs) # Installation directories for `install` command and pkg
 set(LIBSYSTEMD_IMPL "systemd")
 set(LIBSYSTEMD_LIB "libsystemd")

-option(BUILD_LIBSYSTEMD "Build libsystemd static library and incorporate it into libsdbus-c++" OFF)
-
-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(WARNING "libsystemd not found, checking for libelogind instead")
-        pkg_check_modules(Systemd IMPORTED_TARGET GLOBAL libelogind>=236)
+        pkg_check_modules(Systemd IMPORTED_TARGET GLOBAL libelogind>=238)
        if(TARGET PkgConfig::Systemd)
            set(LIBSYSTEMD_IMPL "elogind")
            set(LIBSYSTEMD_LIB "libelogind")
@@ -38,16 +95,16 @@ if(NOT BUILD_LIBSYSTEMD)
        endif()
    endif()
    if(NOT TARGET PkgConfig::Systemd)
-        message(FATAL_ERROR "libsystemd of version at least 236 is required, but was not found "
+        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)
@@ -89,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
@@ -118,16 +177,11 @@ set(CMAKE_CXX_STANDARD 17)
 set(SDBUSCPP_VERSION_MAJOR "${PROJECT_VERSION_MAJOR}")
 set(SDBUSCPP_VERSION "${PROJECT_VERSION}")

-# 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()
-
 # 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}
+    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>
@@ -135,7 +189,7 @@ target_include_directories(sdbus-c++-objlib PUBLIC $<BUILD_INTERFACE:${CMAKE_CUR
 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
@@ -153,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 NAMELINK_COMPONENT dev
-        ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR} COMPONENT dev
-        PUBLIC_HEADER DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${SDBUSCPP_INCLUDE_SUBDIR} COMPONENT dev)
-
 #----------------------------------
 # TESTS
 #----------------------------------

-option(BUILD_TESTS "Build 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")
@@ -184,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()
@@ -195,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()
@@ -206,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()

 #----------------------------------
@@ -221,39 +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)
@@ -239,3 +239,13 @@ v1.4.0
 - 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
@@ -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,35 +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`.

-    * `INSTALL_TESTS` [boolean]
-
-      Option for installing tests that were built. Default value: `OFF`.
-
-    * `TESTS_INSTALL_PATH` [string]
+    * `SDBUSCPP_TESTS_INSTALL_PATH` [string]

      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.

@@ -78,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`

@@ -89,7 +85,7 @@ Dependencies
 * `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
 ---------
@@ -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} -Drootprefix=<INSTALL_DIR> -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
@@ -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()
@@ -22,7 +22,9 @@ Using sdbus-c++ library
 17. [Representing D-Bus Types in sdbus-c++](#representing-d-bus-types-in-sdbus-c)
 18. [Support for match rules](#support-for-match-rules)
 19. [Using direct (peer-to-peer) D-Bus connections](#using-direct-peer-to-peer-d-bus-connections)
-20. [Conclusion](#conclusion)
+20. [Using sdbus-c++ in external event loops](#using-sdbus-c-in-external-event-loops)
+21. [Migrating to sdbus-c++ v2](#migrating-to-sdbus-c-v2)
+22. [Conclusion](#conclusion)

 Introduction
 ------------
@@ -107,9 +109,9 @@ $ ninja libsystemd.so.0.26.0  # or another version number depending which system

 ### Building and distributing libsystemd as part of sdbus-c++

-sdbus-c++ provides `BUILD_LIBSYSTEMD` configuration option. When turned on, sdbus-c++ will automatically download and build libsystemd as a static library and make it an opaque part of sdbus-c++ shared library for you. This is the most convenient and effective approach to build, distribute and use sdbus-c++ as a self-contained, systemd-independent library in non-systemd environments. Just make sure your build machine has all dependencies needed by libsystemd build process. That includes, among others, `meson`, `ninja`, `git`, `gperf`, and -- primarily -- libraries and library headers for `libmount`, `libcap` and `librt` (part of glibc). Also, when distributing, make sure these dependency libraries are installed on the production machine.
+sdbus-c++ provides `SDBUSCPP_BUILD_LIBSYSTEMD` configuration option. When turned on, sdbus-c++ will automatically download and build libsystemd as a static library and make it an opaque part of sdbus-c++ shared library for you. This is the most convenient and effective approach to build, distribute and use sdbus-c++ as a self-contained, systemd-independent library in non-systemd environments. Just make sure your build machine has all dependencies needed by libsystemd build process. That includes, among others, `meson`, `ninja`, `git`, `gperf`, and -- primarily -- libraries and library headers for `libmount`, `libcap` and `librt` (part of glibc). Also, when distributing, make sure these dependency libraries are installed on the production machine.

-You may additionally set the `LIBSYSTEMD_VERSION` configuration flag to fine-tune the version of systemd to be taken in. (The default value is 242).
+You may additionally set the `SDBUSCPP_LIBSYSTEMD_VERSION` configuration flag to fine-tune the version of systemd to be taken in. (The default value is 242).

 Distributing sdbus-c++
 ----------------------
@@ -166,10 +168,10 @@ All public types and functions of sdbus-c++ reside in the `sdbus` namespace.
 Error signalling and propagation
 --------------------------------

-`sdbus::Error` exception is used to signal errors in sdbus-c++. There are two types of errors:
+`sdbus::Error` type is used as an exception to signal errors in sdbus-c++. There are two types of errors:

  * D-Bus related errors, like call timeouts, failed socket allocation, etc. These are raised by the D-Bus library or D-Bus daemon itself.
-  * user-defined errors, i.e. errors signalled and propagated from remote methods back to the caller. So these are issued by sdbus-c++ users.
+  * user-defined errors, i.e. errors signalled and propagated from remote methods back to the caller. So these are issued by sdbus-c++ clients.

 `sdbus::Error` is a carrier for both types of errors, carrying the error name and error message with it.

@@ -305,16 +307,20 @@ int main(int argc, char *argv[])

    // Register D-Bus methods and signals on the concatenator object, and exports the object.
    const char* interfaceName = "org.sdbuscpp.Concatenator";
-    concatenator->registerMethod(interfaceName, "concatenate", "ais", "s", &concatenate);
-    concatenator->registerSignal(interfaceName, "concatenated", "s");
-    concatenator->finishRegistration();
+    concatenator->addVTable( sdbus::MethodVTableItem{"concatenate", "ais", {}, "s", {}, &concatenate, {}}
+                           , sdbus::SignalVTableItem{"concatenated", "s", {}, {}} )
+                           .forInterface(interfaceName);

    // Run the I/O event loop on the bus connection.
    connection->enterEventLoop();
 }
 ```

-We establish a D-Bus system connection and request `org.sdbuscpp.concatenator` D-Bus name on it. This name will be used by D-Bus clients to find the service. We then create an object with path `/org/sdbuscpp/concatenator` on this connection. We register  interfaces, its methods, signals that the object provides, and, through `finishRegistration()`, export the object (i.e., make it visible to clients) on the bus. Then we need to make sure to run the event loop upon the connection, which handles all incoming, outgoing and other requests.
+We establish a D-Bus system connection and request `org.sdbuscpp.concatenator` D-Bus name on it. This name will be used by D-Bus clients to find the service. We then create an object with path `/org/sdbuscpp/concatenator` on this connection. We add a so-called object vtable, where we declare and describe its D-Bus API, i.e. its interface, methods, signals, properties (if any) that the object provides. Then we need to make sure to run the event loop upon the connection, which handles all incoming, outgoing and other requests.
+
+> **_Tip_:** There's also an overload of `addVTable()` method with `return_slot_t` tag parameter which returns a `Slot` object. The slot is a simple RAII-based handle of the associated vtable registration. As long as you keep the slot object, the vtable registration is active. When you let go of the slot, the vtable is automatically removed from the D-Bus object. This gives you the ability to implement "dynamic" D-Bus object API that is addable as well as removable at any time during object lifetime.
+
+> **_Note_:** A D-Bus object can have any number of vtables attached to it. Even a D-Bus interface of an object can have multiple vtables attached to it.

 The callback for any D-Bus object method on this level is any callable of signature `void(sdbus::MethodCall call)`. The `call` parameter is the incoming method call message. We need to deserialize our method input arguments from it. Then we can invoke the logic of the method and get the results. Then for the given `call`, we create a `reply` message, pack results into it and send it back to the caller through `send()`. (If we had a void-returning method, we'd just send an empty `reply` back.) We also fire a signal with the results. To do this, we need to create a signal message via object's `createSignal()`, serialize the results into it, and then send it out to subscribers by invoking object's `emitSignal()`.

@@ -329,7 +335,7 @@ Please note that we can create and destroy D-Bus objects on a connection dynamic
 #include <iostream>
 #include <unistd.h>

-void onConcatenated(sdbus::Signal& signal)
+void onConcatenated(sdbus::Signal signal)
 {
    std::string concatenatedString;
    signal >> concatenatedString;
@@ -349,7 +355,6 @@ int main(int argc, char *argv[])
    // Let's subscribe for the 'concatenated' signals
    const char* interfaceName = "org.sdbuscpp.Concatenator";
    concatenatorProxy->registerSignalHandler(interfaceName, "concatenated", &onConcatenated);
-    concatenatorProxy->finishRegistration();

    std::vector<int> numbers = {1, 2, 3};
    std::string separator = ":";
@@ -364,7 +369,7 @@ int main(int argc, char *argv[])
        assert(result == "1:2:3");
    }

-    // Invoke concatenate again, this time with no numbers and we shall get an error
+/    // Invoke concatenate again, this time with no numbers and we shall get an error
    {
        auto method = concatenatorProxy->createMethodCall(interfaceName, "concatenate");
        method << std::vector<int>() << separator;
@@ -386,9 +391,11 @@ int main(int argc, char *argv[])
 }
 ```

-In simple cases, we don't need to create D-Bus connection explicitly for our proxies. Unless a connection is provided to a proxy object explicitly via factory parameter, the proxy will create a connection of his own, and it will be a system bus connection. This is the case in the example above. (This approach is not scalable and resource-saving if we have plenty of proxies; see section [Working with D-Bus connections](#working-with-d-bus-connections-in-sdbus-c) for elaboration.) So, in the example, we create a proxy for object `/org/sdbuscpp/concatenator` publicly available at bus `org.sdbuscpp.concatenator`. We register signal handlers, if any, and finish the registration, making the proxy ready for use.
+In simple cases, we don't need to create D-Bus connection explicitly for our proxies. We either pass a connection object to the proxy upon creation, or otherwise the proxy will create a connection of his own (to either the session bus or the system bus, depending on the context, see `man sd_bus_open`). This is the case in the example above. (This approach is not scalable and resource-saving if we have plenty of proxies; see section [Working with D-Bus connections](#working-with-d-bus-connections-in-sdbus-c) for elaboration.) So, in the example, we create a proxy for object `/org/sdbuscpp/concatenator` publicly available at bus `org.sdbuscpp.concatenator`. We register handlers for signals we are interested in (if any).

-The callback for a D-Bus signal handler on this level is any callable of signature `void(sdbus::Signal& signal)`. The one and only parameter `signal` is the incoming signal message. We need to deserialize arguments from it, and then we can do our business logic with it.
+The callback for a D-Bus signal handler on this level is any callable of signature `void(sdbus::Signal signal)`. The one and only parameter `signal` is the incoming signal message. We need to deserialize arguments from it, and then we can do our business logic with it.
+
+> **_Tip_:** There's also an overload of `registerSignalHandler()` with `return_slot_t` tag which returns a `Slot` object. The slot is a simple RAII-based handle of the subscription. As long as you keep the slot object, the signal subscription is active. When you let go of the object, the signal handler is automatically unregistered. This gives you finer control over the lifetime of signal subscription.

 Subsequently, we invoke two RPC calls to object's `concatenate()` method. We create a method call message by invoking proxy's `createMethodCall()`. We serialize method input arguments into it, and make a synchronous call via proxy's `callMethod()`. As a return value we get the reply message as soon as it arrives. We deserialize return values from that message, and further use it in our program. The second `concatenate()` RPC call is done with invalid arguments, so we get a D-Bus error reply from the service, which as we can see is manifested via `sdbus::Error` exception being thrown.

@@ -398,10 +405,8 @@ Please note that we can create and destroy D-Bus object proxies dynamically, at

 There are several factory methods to create a bus connection object in sdbus-c++:

-* `createConnection()` - opens a connection to the system bus
-* `createConnection(const std::string& name)` - opens a connection with the given name to the system bus
-* `createDefaultBusConnection()` - opens a connection to the session bus when in a user context, and a connection to the system bus, otherwise
-* `createDefaultBusConnection(const std::string& name)` - opens a connection with the given name to the session bus when in a user context, and a connection with the given name to the system bus, otherwise
+* `createBusConnection()` - opens a connection to the session bus when in a user context, and a connection to the system bus, otherwise
+* `createBusConnection(const std::string& name)` - opens a connection with the given name to the session bus when in a user context, and a connection with the given name to the system bus, otherwise
 * `createSystemBusConnection()` - opens a connection to the system bus
 * `createSystemBusConnection(const std::string& name)` - opens a connection with the given name to the system bus
 * `createSessionBusConnection()` - opens a connection to the session bus
@@ -423,41 +428,51 @@ How shall we use connections in relation to D-Bus objects and object proxies?

 A D-Bus connection is represented by a `IConnection` instance. Each connection needs an event loop being run upon it. So it needs a thread handling the event loop. This thread serves all incoming and outgoing messages and all communication towards D-Bus daemon. One process can have one but also multiple D-Bus connections (we just have to make certain that the connections with assigned bus names don't share a common name; the name must be unique).

-A typical use case for most services is **one** D-Bus connection in the application. The application runs event loop on that connection. When creating objects or proxies, the application provides reference of that connection to those objects and proxies. This means all these objects and proxies share the same connection. This is nicely scalable, because with whatever number of objects or proxies, there is only one connection and one event loop thread. Yet, services that provide objects at various bus names have to create and maintain multiple D-Bus connections, each with the unique bus name.
+A typical use case for most services is **one** D-Bus connection in the application. The application runs an (internal or external, see below) event loop on that connection. When creating objects or proxies, the application provides reference of that connection to those objects and proxies. This means all these objects and proxies share the same connection. This is nicely scalable, because with whatever number of objects or proxies, there is only one connection and one event loop thread. Yet, services that provide objects at various bus names have to create and maintain multiple D-Bus connections, each with the unique bus name.

-The connection is thread-safe and objects and proxies can invoke operations on it from multiple threads simultaneously, but the operations are serialized. This means, for example, that if an object's callback for an incoming remote method call is going to be invoked in an event loop thread, and in another thread we use a proxy to call remote method in another process, the threads are contending and only one can go on while the other must wait and can only proceed after the first one has finished, because both are using a shared resource -- the connection.
+The connection is thread-safe and objects and proxies can invoke operations on it from multiple threads simultaneously, but the operations are serialized. Access to the connection is mutually exclusive. This means, for example, that if an object's callback for an incoming remote method call is going to be invoked in an event loop thread, and in another thread we use a proxy to call remote method in another process, the threads are contending and only one can go on while the other must wait and can only proceed after the first one has finished, because both are using a shared resource -- the connection.

-We should bear that in mind when designing more complex, multi-threaded services with high parallelism. If we have undesired contention on a connection, creating a specific, dedicated connection for a hot spot helps to increase concurrency. sdbus-c++ provides us freedom to create as many connections as we want and assign objects and proxies to those connections at our will. We, as application developers, choose whatever approach is more suitable to us at quite a fine granularity.
+When a `poll()` sleeps upon the connection, the connection can be used by other threads without blocking. When calling a D-Bus method through a proxy synchronously, the proxy blocks the connection from concurrent use until it gets from the peer a reply (or an error, the call times out). Async D-Bus method calls don't block the connection while the call is pending (the connection is only "locked" while the call message is sent out and while the reply handler is executed for an already arrived reply message, but not in between while the call is pending). See doxygen documentation for `IProxy::callMethod()` overloads for more details.
+
+We should bear these design aspects of sdbus-c++ in mind when designing more complex, multi-threaded services with high parallelism. If we have undesired contention on a connection, creating a separate, dedicated connection for a hot spot helps to increase concurrency. sdbus-c++ provides us freedom to create as many connections as we want and assign objects and proxies to those connections at our will. We, as application developers, choose whatever approach is more suitable to us at quite a fine granularity.

 So, more technically, how can we use connections from the server and the client perspective?

 #### Using D-Bus connections on the server side

-On the **server** side, we generally need to create D-Bus objects and publish their APIs. For that we first need a connection with a unique bus name. We need to create the D-Bus connection manually ourselves, request bus name on it, and manually launch its event loop:
+On the **server** side, we generally need to create D-Bus objects and publish their APIs. For that we first need a connection with a unique bus name. We need to create the D-Bus connection manually ourselves, request bus name on it, and manually launch:

-  * either in a blocking way, through `enterEventLoop()`,
-  * or in a non-blocking async way, through `enterEventLoopAsync()`,
-  * or, when we have our own implementation of an event loop (e.g. we are using sd-event event loop), we can ask the connection for its underlying fd, I/O events and timeouts through `getEventLoopPollData()` and use that data in our event loop mechanism.
+  * its internal event loop
+    * either in a blocking way, through `enterEventLoop()`,
+    * or in a non-blocking async way, through `enterEventLoopAsync()`,
+  * or an external event loop. This is suitable if we use in our application an event loop implementation of our choice (e.g., sd-event, GLib Event Loop, boost::asio, ...) and we want to hook up our sdbus-c++ connections with it. See [Using sdbus-c++ in external event loops](#using-sdbus-c-in-external-event-loops) section for more information.

-The object takes the D-Bus connection as a reference in its constructor. This is the only way to wire connection and object together. We must make sure the connection exists as long as objects using it exist.
+The object takes the D-Bus connection as a reference in its constructor. This is the only way to wire the connection and the object together. We must make sure the connection exists as long as objects using it exist.

 Of course, at any time before or after running the event loop on the connection, we can create and "hook", as well as remove, objects and proxies upon that connection.

+*Note:* There may be both objects and proxies hooked to a single connection, of course. A D-Bus server application may also be a client to another D-Bus server application, and share one D-Bus connection for the D-Bus interface it exports as well as for the proxies towards other D-Bus interfaces.
+
 #### Using D-Bus connections on the client side

 On the **client** side we likewise need a connection -- just that unlike on the server side, we don't need to request a unique bus name on it. We have more options here when creating a proxy:

-  * Pass an already existing connection as a reference. This is the typical approach when the application already maintains a D-Bus connection (maybe it provide D-Bus API on it, and/or it already has some proxies hooked on it). The proxy will share the connection with others. With this approach we must of course ensure that the connection exists as long as the proxy exists.
+  * Pass an already existing connection as a reference. This is the typical approach when the application already maintains a D-Bus connection (maybe it provide D-Bus API on it, and/or it already has some proxies hooked on it). The proxy will share the connection with others. With this approach we must of course ensure that the connection exists as long as the proxy exists. For discussion on options for running an event loop on that connection, see above section [Using D-Bus connections on the server side](#using-d-bus-connections-on-the-server-side).

-  * Or -- and this is typical when we have a simple D-Bus client application -- we have another option: we let the proxy maintain its own connection (and potentially an associated event loop thread, see below):
+  * Or -- and this is a simpler approach for  simple D-Bus client applications -- we have another option: we let the proxy maintain its own connection (and potentially an associated event loop thread, see below). We have two options here:

-    * We either create the connection ourselves and `std::move` it to the proxy object factory. The proxy becomes an owner of this connection, and will run the event loop on that connection. This had the advantage that we may choose the type of connection (system, session, remote).
+    * We either create the connection ourselves and `std::move` it to the proxy object factory. The proxy becomes an owner of this connection, and it will be his dedicated connection. This has the advantage that we may choose the type of connection (system, session, remote). Additionally,

-    * Or we don't bother about any connection at all when creating a proxy (the factory overload with no connection parameter). Under the hood, the proxy creates its own *system bus* connection, creates a separate thread and runs an event loop in it. Quite **simple**, but as you can see, this hurts scalability in case of many proxies, as each would spawn and maintain its own event loop thread (see discussion higher above). But we don't necessarily need an event loop thread, in case our proxy doesn't need to listen to signals or async method call replies. Read on.
+      * when created **without** `dont_run_event_loop_thread_t` tag, the proxy **will start** a dedicated event loop thread on that connection;
+      * or, when created **with** `dont_run_event_loop_thread_t` tag, the proxy will start **no** event loop thread on that connection.

-    It's also possible in this case to instruct the proxy to **not spawn an event loop thread** for its connection. There are many situations that we want to quickly create a proxy, carry out one or a few (synchronous) D-Bus calls, and let go of proxy. We call them light-weight proxies. For that purpose, spawning a new event loop thread comes with time and resource penalty, for nothing. To create such **a light-weight proxy**, use the factory/constructor overload with `dont_run_event_loop_thread_t`. All in above two bullet sub-points holds; the proxy just won't spawn a thread with an event loop in it. Note that such a proxy can be used only for synchronous D-Bus calls; it may not receive signals or async call replies.
+    * Or we don't care about connnections at all (proxy factory overloads with no connection parameter). Under the hood, the proxy creates its own connection, to either the session bus (when in a user context) or the system bus otherwise. Additionally:
+      * when created **without** `dont_run_event_loop_thread_t` tag, the proxy **will start** a dedicated event loop thread on that connection;
+      * or, when created **with** `dont_run_event_loop_thread_t` tag, the proxy will start **no** event loop thread on that connection.

-#### Stopping I/O event loops graciously
+    A proxy needs an event loop if it's a "**long-lived**" proxy that listens on incoming messages like signals, async call replies, atc. Sharing one connection with its one event loop is more scalable. Starting a dedicated event loop in a proxy is simpler from API perspective, but comes at a performance and resource cost for each proxy creation/destruction, and it hurts scalability. A simple and scalable option are "**short-lived, light-weight**" proxies. Quite a typical use case is that we occasionally need to carry out one or a few D-Bus calls and that's it. We may create a proxy, do the calls, and let go of proxy. Such a light-weight proxy is created when `dont_run_event_loop_thread_t` tag is passed to the proxy factory. Such a proxy **does not spawn** an event loop thread. It only support synchronous D-Bus calls (no signals, no async calls...), and is meant to be created, used right away, and then destroyed immediately.
+
+#### Stopping internal I/O event loops graciously

 A connection with an asynchronous event loop (i.e. one initiated through `enterEventLoopAsync()`) will stop and join its event loop thread automatically in its destructor. An event loop that blocks in the synchronous `enterEventLoop()` call can be unblocked through `leaveEventLoop()` call on the respective bus connection issued from a different thread or from an OS signal handler.

@@ -515,15 +530,19 @@ int main(int argc, char *argv[])

    // Register D-Bus methods and signals on the concatenator object, and exports the object.
    const char* interfaceName = "org.sdbuscpp.Concatenator";
-    concatenator->registerMethod("concatenate").onInterface(interfaceName).implementedAs(std::move(concatenate));
-    concatenator->registerSignal("concatenated").onInterface(interfaceName).withParameters<std::string>();
-    concatenator->finishRegistration();
+    concatenator->addVTable( sdbus::registerMethod("concatenate").implementedAs(std::move(concatenate))
+                           , sdbus::registerSignal{"concatenated").withParameters<std::string>() )
+                           .forInterface(interfaceName);

    // Run the loop on the connection.
    connection->enterEventLoop();
 }
 ```

+> **_Tip_:** There's also an overload of `addVTable(...).forInterface()` method with `return_slot_t` tag parameter which returns a `Slot` object. The slot is a simple RAII-based handle of the associated vtable registration. As long as you keep the slot object, the vtable registration is active. When you let go of the slot, the vtable is automatically removed from the D-Bus object. This gives you the ability to implement "dynamic" D-Bus object API that is addable as well as removable at any time during object lifetime.
+
+> **_Note_:** A D-Bus object can have any number of vtables attached to it. Even a D-Bus interface of an object can have multiple vtables attached to it.
+
 ### Client side

 ```c++
@@ -548,7 +567,6 @@ int main(int argc, char *argv[])
    // Let's subscribe for the 'concatenated' signals
    const char* interfaceName = "org.sdbuscpp.Concatenator";
    concatenatorProxy->uponSignal("concatenated").onInterface(interfaceName).call([](const std::string& str){ onConcatenated(str); });
-    concatenatorProxy->finishRegistration();

    std::vector<int> numbers = {1, 2, 3};
    std::string separator = ":";
@@ -582,17 +600,19 @@ int main(int argc, char *argv[])

 When registering methods, calling methods or emitting signals, multiple lines of code have shrunk into simple one-liners. Signatures of provided callbacks are introspected and types of provided arguments are deduced at compile time, so the D-Bus signatures as well as serialization and deserialization of arguments to and from D-Bus messages are generated for us completely by the compiler.

+> **_Tip_:** There's also an overload of `uponSignal(...).call()` with `return_slot_t` tag which returns a `Slot` object. The slot is a simple RAII-based handle of the subscription. As long as you keep the slot object, the signal subscription is active. When you let go of the object, the signal handler is automatically unregistered. This gives you finer control over the lifetime of signal subscription.
+
 We recommend that sdbus-c++ users prefer the convenience API to the lower level, basic API. When feasible, using generated adaptor and proxy C++ bindings is even better as it provides yet slightly higher abstraction built on top of the convenience API, where remote calls look simply like local, native calls of object methods. They are described in the following section.

-> **_Note_:** By default, signal callback handlers are not invoked (i.e., the signal is silently dropped) if there is a signal signature mismatch. If clients want to be informed of such situations, they can prepend `const sdbus::Error*` parameter to their signal callback handler's parameter list. This argument will be `nullptr` in normal cases, and will provide access to the corresponding `sdbus::Error` object in case of deserialization failures. An example of a handler with the signature (`int`) different from the real signal contents (`string`):
+> **_Note_:** By default, signal callback handlers are not invoked (i.e., the signal is silently dropped) if there is a signal signature mismatch. If you want to be informed of such situations, you can add `std::optional<sdbus::Error>` parameter to the beginning of your signal callback handler's parameter list. When sdbus-c++ invokes the handler, it will set this argument either to be empty (in normal cases), or to carry a corresponding `sdbus::Error` object (in case of deserialization failures, like type mismatches). An example of a handler with the signature (`int`) different from the real signal contents (`string`):
 > ```c++
->     void onConcatenated(const sdbus::Error* e, int wrongParameter)
+>     void onConcatenated(std::optional<sdbus::Error> e, int wrongParameter)
 >     {
->         assert(e);
+>         assert(e.has_value());
 >         assert(e->getMessage() == "Failed to deserialize a int32 value");
 >     }
 > ```
-> Signature mismatch in signal handlers is probably the most common reason why signals are not received in the client, while we can see them on the bus with `dbus-monitor`. Use `const sdbus::Error*`-based callback variant and inspect the error to check if that's the cause of such problems.
+> Signature mismatch in signal handlers is probably the most common reason why signals are not received in the client, while we can see them on the bus with `dbus-monitor`. Use `std::optional<sdbus::Error>`-based callback variant and inspect the error to check if that's the cause of your problems.

 > **_Tip_:** When registering a D-Bus object, we can additionally provide names of input and output parameters of its methods and names of parameters of its signals. When the object is introspected, these names are listed in the resulting introspection XML, which improves the description of object's interfaces:
 > ```c++
@@ -905,7 +925,7 @@ protected:

 > **_Tip_:** By inheriting from `sdbus::ProxyInterfaces`, we get access to the protected `getProxy()` method. We can call this method inside our proxy implementation class to access the underlying `IProxy` object.

-In the above example, a proxy is created that creates and maintains its own system bus connection. However, there are `ProxyInterfaces` class template constructor overloads that also take the connection from the user as the first parameter, and pass that connection over to the underlying proxy. The connection instance is used by all interfaces listed in the `ProxyInterfaces` template parameter list.
+In the above example, a proxy is created that creates and maintains its own bus connection (the bus is either session bus or system bus depending on the context, see `man sd_bus_open`). However, there are `ProxyInterfaces` class template constructor overloads that also take the connection from the user as the first parameter, and pass that connection over to the underlying proxy. The connection instance is used by all interfaces listed in the `ProxyInterfaces` template parameter list.

 Note however that there are multiple `ProxyInterfaces` constructor overloads, and they differ in how the proxy behaves towards the D-Bus connection. These overloads precisely map the `sdbus::createProxy` overloads, as they are actually implemented on top of them. See [Proxy and D-Bus connection](#Proxy-and-D-Bus-connection) for more info. We can even create a `IProxy` instance on our own, and inject it into our proxy class -- there is a constructor overload for it in `ProxyInterfaces`. This can help if we need to provide mocked implementations in our unit tests.

@@ -1106,15 +1126,15 @@ int main(int argc, char *argv[])
 {
    /* ...  */

-    auto callback = [](MethodReply& reply, const sdbus::Error* error)
+    auto callback = [](MethodReply reply, std::optional<sdbus::Error> error)
    {
-        if (error == nullptr) // No error
+        if (!error) // No error
        {
            std::string result;
            reply >> result;
            std::cout << "Got concatenate result: " << result << std::endl;
        }
-        else // We got a D-Bus error...
+        else // We've got a D-Bus error...
        {
            std::cerr << "Got concatenate error " << error->getName() << " with message " << error->getMessage() << std::endl;
        }
@@ -1142,7 +1162,7 @@ int main(int argc, char *argv[])
 }
 ```

-The callback is a void-returning function taking two arguments: a reference to the reply message, and a pointer to the prospective `sdbus::Error` instance. Zero `Error` pointer means that no D-Bus error occurred while making the call, and the reply message contains valid reply. Non-zero `Error` pointer, however, points to the valid `Error` instance, meaning that an error occurred. Error name and message can then be read out by the client from that instance.
+The callback is a void-returning function taking two arguments: a reference to the reply message, and a pointer to the prospective `sdbus::Error` instance. Empty `error` optional argument means that no D-Bus error occurred while making the call, and the reply message contains a valid reply. A non-empty `error` argument means that an error occurred during the call, and we can access the error name and message from the `Error` value inside the argument.

 There is also an overload of this `IProxy::callMethod()` function taking method call timeout argument.

@@ -1171,16 +1191,16 @@ Another option is to use `std::future`-based overload of the `IProxy::callMethod

 ### Convenience API

-On the convenience API level, the call statement starts with `callMethodAsync()`, and one option is to finish the statement with `uponReplyInvoke()` that takes a callback handler. The callback is a void-returning function that takes at least one argument: pointer to the `sdbus::Error` instance. All subsequent arguments shall exactly reflect the D-Bus method output arguments. A concatenator example:
+On the convenience API level, the call statement starts with `callMethodAsync()`, and one option is to finish the statement with `uponReplyInvoke()` that takes a callback handler. The callback is a void-returning function that takes at least one argument: `std::optional<sdbus::Error>`. All subsequent arguments shall exactly reflect the D-Bus method output arguments. A concatenator example:

 ```c++
 int main(int argc, char *argv[])
 {
    /* ...  */

-    auto callback = [](const sdbus::Error* error, const std::string& concatenatedString)
+    auto callback = [](std::optional<sdbus::Error> error, const std::string& concatenatedString)
    {
-        if (error == nullptr) // No error
+        if (!error) // No error
            std::cout << "Got concatenate result: " << concatenatedString << std::endl;
        else // We got a D-Bus error...
            std::cerr << "Got concatenate error " << error->getName() << " with message " << error->getMessage() << std::endl;
@@ -1204,7 +1224,7 @@ int main(int argc, char *argv[])
 }
 ```

-When the `Error` pointer is zero, it means that no D-Bus error occurred while making the call, and subsequent arguments are valid D-Bus method return values. Non-zero `Error` pointer, however, points to the valid `Error` instance, meaning that an error occurred during the call (and subsequent arguments are simply default-constructed). Error name and message can then be read out by the client from `Error` instance.
+Empty `error` parameter means that no D-Bus error occurred while making the call, and subsequent arguments are valid D-Bus method return values. However, `error` parameter containing a value means that an error occurred during the call (and subsequent arguments are simply default-constructed), and the underlying `Error` instance provides us with the error name and message.

 Another option is to finish the async call statement with `getResultAsFuture()`, which is a template function which takes the list of types returned by the D-Bus method (empty list in case of `void`-returning method) which returns a `std::future` object, which will later, when the reply arrives, be set to contain the return value(s). Or if the call returns an error, `sdbus::Error` will be thrown by `std::future::get()`.

@@ -1253,7 +1273,7 @@ An asynchronous method can be generated as a callback-based method or `std::futu

 For each client-side async method, a corresponding `on<MethodName>Reply` pure virtual function, where `<MethodName>` is the capitalized D-Bus method name, is generated in the generated proxy class. This function is the callback invoked when the D-Bus method reply arrives, and must be provided a body by overriding it in the implementation class.

-So in the specific example above, the tool will generate a `Concatenator_proxy` class similar to one shown in a [dedicated section above](#concatenator-client-glueh), with the difference that it will also generate an additional `virtual void onConcatenateReply(const sdbus::Error* error, const std::string& concatenatedString);` method, which we shall override in derived `ConcatenatorProxy`.
+So in the specific example above, the tool will generate a `Concatenator_proxy` class similar to one shown in a [dedicated section above](#concatenator-client-glueh), with the difference that it will also generate an additional `virtual void onConcatenateReply(std::optional<sdbus::Error> error, const std::string& concatenatedString);` method, which we shall override in the derived `ConcatenatorProxy`.

 #### Generating std:future-based async methods

@@ -1303,7 +1323,7 @@ Getting a property in asynchronous manner is also possible, in both callback-bas

 ```c++
 // Callback-based method:
-auto callback = [](const sdbus::Error* err, sdbus::Variant value)
+auto callback = [](std::optional<sdbus::Error> /*error*/, sdbus::Variant value)
 {
    std::cout << "Got property value: " << value.get<uint32_t>() << std::endl;
 };
@@ -1314,7 +1334,7 @@ std::future<sdbus::Variant> statusFuture = object.getPropertyAsync("status").onI
 std::cout << "Got property value: " << statusFuture.get().get<uint32_t>() << std::endl;
 ```

-More information on `error` callback handler parameter, on behavior of `future` in erroneous situations, can be found in section [Asynchronous client-side methods](#asynchronous-client-side-methods).
+More information on an `error` callback handler parameter, on behavior of `future` in erroneous situations, can be found in section [Asynchronous client-side methods](#asynchronous-client-side-methods).

 #### Writing a property

@@ -1329,7 +1349,7 @@ Setting a property in asynchronous manner is also possible, in both callback-bas

 ```c++
 // Callback-based method:
-auto callback = [](const sdbus::Error* err) { /*... Error handling in case err is non-null...*/ };
+auto callback = [](std::optional<sdbus::Error> error { /*... Error handling in case error contains a value...*/ };
 uint32_t status = proxy->setPropertyAsync("status").onInterface("org.sdbuscpp.Concatenator").toValue(status).uponReplyInvoke(std::move(callback));
 // Future-based method:
 std::future<void> statusFuture = object.setPropertyAsync("status").onInterface("org.sdbuscpp.Concatenator").getResultAsFuture();
@@ -1452,13 +1472,13 @@ class PropertyProvider_proxy
 {
    /*...*/

-    virtual void onStatusPropertyGetReply(const uint32_t& value, const sdbus::Error* error) = 0;
+    virtual void onStatusPropertyGetReply(const uint32_t& value, std::optional<sdbus::Error> error) = 0;

 public:
    // getting the property value
    sdbus::PendingAsyncCall status()
    {
-        return object_->getPropertyAsync("status").onInterface(INTERFACE_NAME).uponReplyInvoke([this](const sdbus::Error* error, const sdbus::Variant& value){ this->onActionPropertyGetReply(value.get<uint32_t>(), error); });
+        return object_->getPropertyAsync("status").onInterface(INTERFACE_NAME).uponReplyInvoke([this](std::optional<sdbus::Error> error, const sdbus::Variant& value){ this->onStatusPropertyGetReply(value.get<uint32_t>(), std::move(error)); });
    }

    // setting the property value
@@ -1489,7 +1509,7 @@ Pre-generated `*_proxy` and `*_adaptor` convenience classes for these standard i

 For example, for our `Concatenator` example above in this tutorial, we may want to conveniently emit a `PropertyChanged` signal under `org.freedesktop.DBus.Properties` interface. First, we must augment our `Concatenator` class to also inherit from `org.freedesktop.DBus.Properties` interface: `class Concatenator : public sdbus::AdaptorInterfaces<org::sdbuscpp::Concatenator_adaptor, sdbus::Properties_adaptor> {...};`, and then we just issue `emitPropertiesChangedSignal` function of our adaptor object.

-Note that signals of afore-mentioned standard D-Bus interfaces are not emitted by the library automatically. It's clients who are supposed to emit them.
+Note that signals of afore-mentioned standard D-Bus interfaces are not emitted by the library automatically. It's you, the user of sdbus-c++, who are supposed to emit them.

 Working examples of using standard D-Bus interfaces can be found in [sdbus-c++ integration tests](/tests/integrationtests/DBusStandardInterfacesTests.cpp) or the [examples](/examples) directory.

@@ -1502,23 +1522,23 @@ sdbus-c++ provides many default, pre-defined C++ type representations for D-Bus
 | Category            | Code        | Code ASCII | Conventional Name  | C++ Type                        |
 |---------------------|-------------|------------|--------------------|---------------------------------|
 | reserved            | 0           | NUL        | INVALID            | -                               |
-| fixed, basic        | 121         | y          | BYTE               | `uint8_t`                         |
-| fixed, basic        | 98          | b          | BOOLEAN            | `bool`                            |
-| fixed, basic        | 110         | n          | INT16              | `int16_t`                         |
-| fixed, basic        | 113         | q          | UINT16             | `uint16_t`                        |
-| fixed, basic        | 105         | i          | INT32              | `int32_t`                         |
-| fixed, basic        | 117         | u          | UINT32             | `uint32_t`                        |
-| fixed, basic        | 120         | x          | INT64              | `int64_t`                         |
-| fixed, basic        | 116         | t          | UINT64             | `uint64_t`                        |
-| fixed, basic        | 100         | d          | DOUBLE             | `double`                          |
-| string-like, basic  | 115         | s          | STRING             | `const char*`, `std::string`        |
-| string-like, basic  | 111         | o          | OBJECT_PATH        | `sdbus::ObjectPath`               |
-| string-like, basic  | 103         | g          | SIGNATURE          | `sdbus::Signature`                |
+| fixed, basic        | 121         | y          | BYTE               | `uint8_t`                       |
+| fixed, basic        | 98          | b          | BOOLEAN            | `bool`                          |
+| fixed, basic        | 110         | n          | INT16              | `int16_t`                       |
+| fixed, basic        | 113         | q          | UINT16             | `uint16_t`                      |
+| fixed, basic        | 105         | i          | INT32              | `int32_t`                       |
+| fixed, basic        | 117         | u          | UINT32             | `uint32_t`                      |
+| fixed, basic        | 120         | x          | INT64              | `int64_t`                       |
+| fixed, basic        | 116         | t          | UINT64             | `uint64_t`                      |
+| fixed, basic        | 100         | d          | DOUBLE             | `double`                        |
+| string-like, basic  | 115         | s          | STRING             | `const char*`, `std::string`    |
+| string-like, basic  | 111         | o          | OBJECT_PATH        | `sdbus::ObjectPath`             |
+| string-like, basic  | 103         | g          | SIGNATURE          | `sdbus::Signature`              |
 | container           | 97          | a          | ARRAY              | `std::vector<T>`, `std::array<T>`, `std::span<T>` - if used as an array followed by a single complete type `T` <br /> `std::map<T1, T2>`, `std::unordered_map<T1, T2>` - if used as an array of dict entries |
-| container           | 114,40,41   | r()        | STRUCT             | `sdbus::Struct<T1, T2, ...>` variadic class template                               |
-| container           | 118         | v          | VARIANT            | `sdbus::Variant`                  |
+| container           | 114,40,41   | r()        | STRUCT             | `sdbus::Struct<T1, T2, ...>` variadic class template                                                                                                                                                         |
+| container           | 118         | v          | VARIANT            | `sdbus::Variant`                |
 | container           | 101,123,125 | e{}        | DICT_ENTRY         | -                               |
-| fixed, basic        | 104         | h          | UNIX_FD            | `sdbus::UnixFd`                   |
+| fixed, basic        | 104         | h          | UNIX_FD            | `sdbus::UnixFd`                 |
 | reserved            | 109         | m          | (reserved)         | -                               |
 | reserved            | 42          | *          | (reserved)         | -                               |
 | reserved            | 63          | ?          | (reserved)         | -                               |
@@ -1536,7 +1556,7 @@ For more information on basic D-Bus types, D-Bus container types, and D-Bus type

 ### Extending sdbus-c++ type system

-The above mapping between D-Bus and C++ types is what sdbus-c++ provides by default. However, the mapping can be extended. Clients can implement additional mapping between a D-Bus type and their custom type.
+The above mapping between D-Bus and C++ types is what sdbus-c++ provides by default. However, the mapping can be extended. You can implement additional mapping between a D-Bus type and their custom type.

 We need two things to do that:

@@ -1699,6 +1719,59 @@ int main(int argc, char *argv[])

 > **_Note_:** The example above explicitly stops the event loops on both sides, before the connection objects are destroyed. This avoids potential `Connection reset by peer` errors caused when one side closes its socket while the other side is still working on the counterpart socket. This is a recommended workflow for closing direct D-Bus connections.

+Using sdbus-c++ in external event loops
+---------------------------------------
+
+sdbus-c++ connections can be hooked up with an external (like GMainLoop, boost::asio, etc.) or manual event loop involving `poll()` or a similar I/O polling call. The following describes how to integrate it correctly:
+
+Before **each** invocation of the I/O polling call, `IConnection::getEventLoopPollData()` 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 up to the returned `PollData::timeout`. Additionally, returned `PollData::eventFd` should be polled for POLLIN events.
+
+After each I/O polling call (for both `PollData::fd` and `PollData::eventFd` events), the `IConnection::processPendingEvent()` method should be invoked. This enables the bus connection to process any incoming or outgoing D-Bus messages.
+
+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 into a form that can be passed to `poll()`.
+
+`PollData::fd` is a bus I/O fd. `PollData::eventFd` is an sdbus-c++ internal fd for communicating important changes from other threads to the event loop thread, so the event loop retrieves new poll data (with updated timeout, for example) and, potentially, processes pending D-Bus messages (like signals that came in during a blocking synchronous call from other thread, or queued outgoing messages that are very big to be able to have been sent in one shot from another thread), before the next poll.
+
+Consult `IConnection::PollData` and `IConnection::getEventLoopPollData()` documentation for potentially more information.
+
+### Integration of sd-event event loop
+
+sdbus-c++ provides built-in integration of sd-event, which makes it very convenient to hook sdbus-c++ connection up with an sd-event event loop.
+
+See documentation of `IConnection::attachSdEventLoop()`, `IConnection::detachSdEventLoop()`, and `IConnection::getSdEventLoop()` methods, or sdbus-c++ integration tests for an example of use. These methods are sdbus-c++ counterparts to and mimic the behavior of these underlying sd-bus functions: `sd_bus_attach_event()`, `sd_bus_detach_event()`, and `sd_bus_get_event()`. Their manual pages provide much more details about their behavior.
+
+Migrating to sdbus-c++ v2
+-------------------------
+
+sdbus-c++ v2 is a major release that comes with a number of breaking API/ABI/behavior changes compared to v1. The following list describes the changes:
+
+* Change in behavior: In *synchronous* D-Bus calls, the proxy object now keeps the connection instance blocked for the entire duration of the method call. Incoming messages like signals will be queued and processed after the call. Access to the connection from other threads is blocked. To avoid this (in case this hurts you):
+  * either use short-lived, light-weight proxies for such synchronous calls,
+  * or call the method in an asynchronous way.
+* Signatures of callbacks `async_reply_handler`, `signal_handler`, `message_handler` and `property_set_callback` were modified to take input message objects by value instead of non-const ref to a message. The callback handler assumes ownership of the message. This API is cleaner and more self-explaining.
+* The `PollData` struct has been extended with a new data member: `eventFd`. All hooks with external event loops shall be modified to poll on this `eventFd` in addition to the `fd`.
+* `PollData::timeout_usec` was renamed to `PollData::timeout` and its type has been changed to `std::chrono::microseconds`. This member now holds directly what before had to be obtained through `PollData::getAbsoluteTimeout()` call.
+* `PollData::getRelativeTimeout()` return type was changed to `std::chrono::microseconds`.
+* `IConnection::processPendingRequest()` was renamed to `IConnection::processPendingEvent()`.
+* `Variant` constructor is now explicit.
+* `IProxy::getCurrentlyProcessedMessage()` now returns `Message` by value instead of a raw pointer to it. The caller assumes ownership of the message.
+* Object D-Bus API registration is now done through `IObject::addVTable()` method. The vtable gets active immediately. No `finishRegistration()` call is needed anymore. vtables can be added and removed dynamically at run time. In addition to API simplification this brings consistency with sd-bus API and increases flexibility.
+* Subscription to signals has been simplified. The subscription is active right after the `registerSignalHandler`/`uponSignal()` call. No need for the final call to `finishRegistration()`.
+* `IProxy::muteSignal()` and `IProxy::unregisterSignal()` have been removed. When subscribing to a signal, we can ask sdbus-c++ to give us a RAII-based slot object. As long as we keep the slot, the subscription is active. Destroying the slot object implies unsubscribing from the signal.
+* `request_slot` tag was renamed to `return_slot`.
+* Deprecated `dont_request_slot` was removed. It shall be replaced with `floating_slot`.
+* `ProxyInterfaces::getObjectPath()` was removed. It shall be replaced with `ProxyInterfaces::getProxy().getObjectPath()`.
+* `AdaptorInterfaces::getObjectPath()` was removed. It can be replaced with `AdaptorInterfaces::getObject().getObjectPath()`.
+* `createConnection()` has been removed. To create a connection to the system bus use `createSystemConnection()` instead.
+* `createDefaultBusConnection()` has been renamed to `createBusConnection()`.
+* Change in behavior: `Proxy`s now by default call `createBusConnection()` to get a connection when the connection is not provided explicitly by the caller, so they connect to either the session bus or the system bus depending on the context (as opposed to always to the system bus like before).
+* Callbacks taking `const sdbus::Error* error` were changed to take `std::optional<sdbus::Error>`, which better expresses the intent and meaning.
+* Types and methods marked deprecated in sdbus-c++ v1 were removed completely.
+* CMake options got `SDBUSCPP_` prefix for better usability and minimal risk of conflicts in downstream CMake projects. `SDBUSCPP_INSTALL` CMake option was added.
+* CMake components got `sdbus-c++-` prefix.
+
+Some of these changes required correspoding adaptations in the sdbus-c++ codegen. Hence, your **C++ bindings (if any) must be re-generated** with the new sdbus-c++-xml2cpp v2 in order to use them with sdbus-c++ v2 API.
+
 Conclusion
 ----------

@@ -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()
@@ -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
@@ -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
@@ -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;
-}
+}
@@ -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,12 +133,9 @@ 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;
@@ -30,13 +30,14 @@
 #include <sdbus-c++/Message.h>
 #include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Types.h>
-#include <sdbus-c++/Flags.h>
+#include <sdbus-c++/VTableItems.h>
+
+#include <chrono>
+#include <cstdint>
+#include <future>
+#include <map>
 #include <string>
 #include <vector>
-#include <type_traits>
-#include <chrono>
-#include <future>
-#include <cstdint>

 // Forward declarations
 namespace sdbus {
@@ -48,101 +49,16 @@ namespace sdbus {

 namespace sdbus {

-    class MethodRegistrator
+    class VTableAdder
    {
    public:
-        MethodRegistrator(IObject& object, 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_;
-        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, 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_;
-        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
@@ -214,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_;
@@ -221,17 +141,6 @@ namespace sdbus {
        std::string interfaceName_;
    };

-    class SignalUnsubscriber
-    {
-    public:
-        SignalUnsubscriber(IProxy& proxy, const std::string& signalName);
-        void onInterface(const std::string& interfaceName);
-
-    private:
-        IProxy& proxy_;
-        const std::string& signalName_;
-    };
-
    class PropertyGetter
    {
    public:
@@ -313,6 +222,6 @@ namespace sdbus {
        const std::string* interfaceName_{};
    };

-}
+} // namespace sdbus

 #endif /* SDBUS_CXX_CONVENIENCEAPICLASSES_H_ */
@@ -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, std::string methodName)
+    inline VTableAdder::VTableAdder(IObject& object, std::vector<VTableItem> vtable)
        : object_(object)
-        , methodName_(std::move(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_)
-                              , inputParamNames_
-                              , std::move(outputSignature_)
-                              , 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, std::string signalName)
-        : object_(object)
-        , signalName_(std::move(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_)
-                              , 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_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 (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_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 (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
                {
@@ -597,16 +249,16 @@ namespace sdbus {
                {
                    // 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);
+                    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>
@@ -615,15 +267,15 @@ namespace sdbus {
        auto promise = std::make_shared<std::promise<future_return_t<_Args...>>>();
        auto future = promise->get_future();

-        uponReplyInvoke([promise = std::move(promise)](const Error* error, _Args... args)
+        uponReplyInvoke([promise = std::move(promise)](std::optional<Error> error, _Args... args)
        {
-            if (error == nullptr)
+            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(*error));
+                promise->set_exception(std::make_exception_ptr(*std::move(error)));
        });

        // Will be std::future<void> for no D-Bus method return value
@@ -656,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
@@ -677,12 +346,12 @@ namespace sdbus {
                {
                    // 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);
+                    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
            {
@@ -692,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(const std::string& interfaceName)
-    {
-        proxy_.unregisterSignalHandler(interfaceName, signalName_);
+        };
    }

    /*** -------------- ***/
@@ -750,7 +404,7 @@ namespace sdbus {
    template <typename _Function>
    PendingAsyncCall AsyncPropertyGetter::uponReplyInvoke(_Function&& callback)
    {
-        static_assert(std::is_invocable_r_v<void, _Function, const Error*, Variant>, "Property get callback function must accept Error* and property value as Variant");
+        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

@@ -851,7 +505,7 @@ namespace sdbus {
    template <typename _Function>
    PendingAsyncCall AsyncPropertySetter::uponReplyInvoke(_Function&& callback)
    {
-        static_assert(std::is_invocable_r_v<void, _Function, const Error*>, "Property set callback function must accept Error* only");
+        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

@@ -909,8 +563,8 @@ namespace sdbus {
    template <typename _Function>
    PendingAsyncCall AsyncAllPropertiesGetter::uponReplyInvoke(_Function&& callback)
    {
-        static_assert( std::is_invocable_r_v<void, _Function, const Error*, std::map<std::string, Variant>>
-                     , "All properties get callback function must accept Error* and a map of property names to their values" );
+        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

@@ -930,6 +584,6 @@ namespace sdbus {
                     .getResultAsFuture<std::map<std::string, Variant>>();
    }

-}
+} // namespace sdbus

 #endif /* SDBUS_CPP_CONVENIENCEAPICLASSES_INL_ */
@@ -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();
        }
@@ -74,21 +74,21 @@ 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_;
@@ -28,13 +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 {

@@ -51,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;

@@ -129,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
@@ -163,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
@@ -248,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
@@ -278,7 +270,7 @@ namespace sdbus {
         * 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
@@ -347,32 +339,53 @@ namespace sdbus {
        virtual void addMatchAsync(const std::string& match, message_handler callback, message_handler installCallback, floating_slot_t) = 0;

        /*!
-         * @copydoc IConnection::enterEventLoop()
+         * @struct PollData
         *
-         * @deprecated This function has been replaced by enterEventLoop()
+         * Carries poll data needed for integration with external event loop implementations.
+         *
+         * See getEventLoopPollData() for more info.
         */
-        [[deprecated("This function has been replaced by enterEventLoop()")]] void enterProcessingLoop();
+        struct PollData
+        {
+            /*!
+             * The read fd to be monitored by the event loop.
+             */
+            int fd;

-        /*!
-         * @copydoc IConnection::enterEventLoopAsync()
-         *
-         * @deprecated This function has been replaced by enterEventLoopAsync()
-         */
-        [[deprecated("This function has been replaced by enterEventLoopAsync()")]] void enterProcessingLoopAsync();
+            /*!
+             * The events to use for poll(2) alongside fd.
+             */
+            short int events;

-        /*!
-         * @copydoc IConnection::leaveEventLoop()
-         *
-         * @deprecated This function has been replaced by leaveEventLoop()
-         */
-        [[deprecated("This function has been replaced by leaveEventLoop()")]] void leaveProcessingLoop();
+            /*!
+             * 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;

-        /*!
-         * @copydoc IConnection::getEventLoopPollData()
-         *
-         * @deprecated This function has been replaced by getEventLoopPollData()
-         */
-        [[deprecated("This function has been replaced by getEventLoopPollData()")]] PollData getProcessLoopPollData() const;
+            /*!
+             * 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>
@@ -382,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.
     *
@@ -428,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.
@@ -438,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
@@ -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_ */
@@ -29,11 +29,12 @@

 #include <sdbus-c++/ConvenienceApiClasses.h>
 #include <sdbus-c++/TypeTraits.h>
-#include <string>
-#include <memory>
-#include <functional>
+
 #include <chrono>
+#include <functional>
 #include <future>
+#include <memory>
+#include <string>

 // Forward declarations
 namespace sdbus {
@@ -80,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 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;

@@ -116,66 +126,76 @@ namespace sdbus {
         * @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 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;
-
-        /*!
-         * @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;
+        template <typename _Rep, typename _Period>
+        std::future<MethodReply> callMethodAsync( const MethodCall& message
+                                                , const std::chrono::duration<_Rep, _Period>& timeout
+                                                , with_future_t );

        /*!
         * @brief Calls method on the D-Bus object
@@ -222,6 +242,42 @@ namespace sdbus {
         */
        [[nodiscard]] AsyncMethodInvoker callMethodAsync(const std::string& methodName);

+        /*!
+         * @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
         *
@@ -233,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); });
@@ -243,21 +302,15 @@ namespace sdbus {
        [[nodiscard]] SignalSubscriber uponSignal(const std::string& signalName);

        /*!
-         * @brief Unregisters signal handler of a given signal of the 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 D-Bus object
@@ -290,7 +343,7 @@ namespace sdbus {
         * Example of use:
         * @code
         * std::future<sdbus::Variant> state = object.getPropertyAsync("state").onInterface("com.kistler.foo").getResultAsFuture();
-         * auto callback = [](const sdbus::Error* err, const sdbus::Variant& value){ ... };
+         * auto callback = [](std::optional<sdbus::Error> err, const sdbus::Variant& value){ ... };
         * object.getPropertyAsync("state").onInterface("com.kistler.foo").uponReplyInvoke(std::move(callback));
         * @endcode
         *
@@ -367,7 +420,7 @@ namespace sdbus {
         *
         * Example of use:
         * @code
-         * auto callback = [](const sdbus::Error* err, const std::map<std::string, Variant>>& properties){ ... };
+         * 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
         *
@@ -380,55 +433,27 @@ namespace sdbus {
         *
         * @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;
-
-        /*!
-         * @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.
-         *
-         * Note: To avoid messing with messages, use higher-level API defined below.
-         *
-         * @throws sdbus::Error in case of failure
-         */
-        virtual std::future<MethodReply> callMethod(const MethodCall& message, with_future_t) = 0;
-        virtual std::future<MethodReply> callMethod(const MethodCall& message, uint64_t timeout, with_future_t) = 0;
-
-        /*!
-         * @copydoc IProxy::callMethod(const MethodCall&,uint64_t,with_future_t)
-         */
-        template <typename _Rep, typename _Period>
-        std::future<MethodReply> callMethod( const MethodCall& message
-                                           , const std::chrono::duration<_Rep, _Period>& timeout
-                                           , with_future_t );
+        [[nodiscard]] virtual Message getCurrentlyProcessedMessage() const = 0;
    };

    /********************************************//**
@@ -463,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;
@@ -483,19 +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::callMethod( const MethodCall& message
-                                                      , const std::chrono::duration<_Rep, _Period>& timeout
-                                                      , with_future_t )
+    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 callMethod(message, microsecs.count(), with_future);
+        return callMethodAsync(message, microsecs.count(), with_future);
    }

    inline MethodInvoker IProxy::callMethod(const std::string& methodName)
@@ -513,11 +540,6 @@ 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);
@@ -27,22 +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 <sdbus-c++/TypeTraits.h>
+
+#include <algorithm>
 #include <array>
+#include <cassert>
+#include <cstdint>
+#include <functional>
+#include <map>
 #if __cplusplus >= 202002L
 #include <span>
 #endif
-#include <map>
+#include <string>
+#include <sys/types.h>
 #include <unordered_map>
 #include <utility>
-#include <cstdint>
-#include <cassert>
-#include <functional>
-#include <sys/types.h>
-#include <algorithm>
+#include <vector>

 // Forward declarations
 namespace sdbus {
@@ -54,7 +55,6 @@ namespace sdbus {
    class MethodReply;
    namespace internal {
        class ISdBus;
-        class IConnection;
    }
 }

@@ -69,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);
@@ -214,13 +220,6 @@ namespace sdbus {
        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:
@@ -238,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;

@@ -249,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
@@ -28,9 +28,10 @@
 #define SDBUS_CXX_METHODRESULT_H_

 #include <sdbus-c++/Message.h>
+
 #include <cassert>

-// Forward declaration
+// Forward declarations
 namespace sdbus {
    class Error;
 }
@@ -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>
@@ -173,15 +174,15 @@ namespace sdbus {
        }

        /*!
-         * @brief Finishes proxy registration and makes the proxy ready for use
+         * @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(), ...);
        }

        /*!
@@ -197,12 +198,9 @@ 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;
@@ -54,6 +54,10 @@ namespace sdbus {

        ~Peer_proxy() = default;

+        void registerProxy()
+        {
+        }
+
    public:
        void Ping()
        {
@@ -89,6 +93,10 @@ namespace sdbus {

        ~Introspectable_proxy() = default;

+        void registerProxy()
+        {
+        }
+
    public:
        std::string Introspect()
        {
@@ -109,6 +117,17 @@ namespace sdbus {
    protected:
        Properties_proxy(sdbus::IProxy& 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")
@@ -121,13 +140,6 @@ namespace sdbus {
                            });
        }

-        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;
-
        virtual void onPropertiesChanged( const std::string& interfaceName
                                        , const std::map<std::string, sdbus::Variant>& changedProperties
                                        , const std::vector<std::string>& invalidatedProperties ) = 0;
@@ -198,6 +210,17 @@ namespace sdbus {
    protected:
        ObjectManager_proxy(sdbus::IProxy& 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")
@@ -217,13 +240,6 @@ namespace sdbus {
                            });
        }

-        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;
-
        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
@@ -251,8 +267,7 @@ 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)
        {
        }

@@ -263,6 +278,10 @@ namespace sdbus {

        ~Properties_adaptor() = default;

+        void registerAdaptor()
+        {
+        }
+
    public:
        void emitPropertiesChangedSignal(const std::string& interfaceName, const std::vector<std::string>& properties)
        {
@@ -293,10 +312,8 @@ 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;
@@ -306,6 +323,11 @@ namespace sdbus {

        ~ObjectManager_adaptor() = default;

+        void registerAdaptor()
+        {
+            object_->addObjectManager();
+        }
+
    private:
        sdbus::IObject* object_;
    };
@@ -336,6 +358,10 @@ namespace sdbus {

        ~ManagedObject_adaptor() = default;

+        void registerAdaptor()
+        {
+        }
+
    public:
        /*!
         * @brief Emits InterfacesAdded signal for this object path
@@ -27,19 +27,23 @@
 #ifndef SDBUS_CXX_TYPETRAITS_H_
 #define SDBUS_CXX_TYPETRAITS_H_

-#include <type_traits>
-#include <string>
-#include <vector>
+#include <sdbus-c++/Error.h>
+
 #include <array>
+#include <cstdint>
+#include <functional>
+#include <map>
+#include <memory>
+#include <optional>
 #if __cplusplus >= 202002L
 #include <span>
 #endif
-#include <map>
-#include <unordered_map>
-#include <cstdint>
-#include <functional>
-#include <memory>
+#include <string>
 #include <tuple>
+#include <type_traits>
+#include <unordered_map>
+#include <variant>
+#include <vector>

 // Forward declarations
 namespace sdbus {
@@ -62,24 +66,21 @@ 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{};
@@ -492,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;
@@ -646,6 +647,15 @@ namespace sdbus {
    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>
@@ -658,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).
@@ -704,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>{} );
    }
@@ -29,11 +29,12 @@

 #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 <utility>

 namespace sdbus {
@@ -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());
@@ -255,7 +256,7 @@ namespace sdbus {
            close();
        }

-        int get() const
+        [[nodiscard]] int get() const
        {
            return fd_;
        }
@@ -275,7 +276,7 @@ namespace sdbus {
            return std::exchange(fd_, -1);
        }

-        bool isValid() const
+        [[nodiscard]] bool isValid() const
        {
            return fd_ >= 0;
        }
@@ -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_ */
@@ -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_ */
@@ -25,63 +25,69 @@
 */

 #include "Connection.h"
-#include "SdBus.h"
+
+#include "sdbus-c++/Error.h"
+#include "sdbus-c++/Message.h"
+
 #include "MessageUtils.h"
-#include "Utils.h"
-#include <sdbus-c++/Message.h>
-#include <sdbus-c++/Error.h>
 #include "ScopeGuard.h"
-#include SDBUS_HEADER
-#include <unistd.h>
+#include "SdBus.h"
+#include "Utils.h"
+
 #include <poll.h>
 #include <sys/eventfd.h>
+#include SDBUS_HEADER
+#ifndef SDBUS_basu // sd_event integration is not supported in basu-based sdbus-c++
+#include <systemd/sd-event.h>
+#endif
+#include <unistd.h>

 namespace sdbus::internal {

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, const BusFactory& busFactory)
-    : iface_(std::move(interface))
+    : sdbus_(std::move(interface))
    , bus_(openBus(busFactory))
 {
-    assert(iface_ != nullptr);
+    assert(sdbus_ != nullptr);
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, default_bus_t)
-    : Connection(std::move(interface), [this](sd_bus** bus){ return iface_->sd_bus_open(bus); })
+    : Connection(std::move(interface), [this](sd_bus** bus){ return sdbus_->sd_bus_open(bus); })
 {
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, system_bus_t)
-    : Connection(std::move(interface), [this](sd_bus** bus){ return iface_->sd_bus_open_system(bus); })
+    : Connection(std::move(interface), [this](sd_bus** bus){ return sdbus_->sd_bus_open_system(bus); })
 {
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, session_bus_t)
-    : Connection(std::move(interface), [this](sd_bus** bus){ return iface_->sd_bus_open_user(bus); })
+    : Connection(std::move(interface), [this](sd_bus** bus){ return sdbus_->sd_bus_open_user(bus); })
 {
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, custom_session_bus_t, const std::string& address)
-        : Connection(std::move(interface), [&](sd_bus** bus) { return iface_->sd_bus_open_user_with_address(bus, address.c_str()); })
+        : Connection(std::move(interface), [&](sd_bus** bus) { return sdbus_->sd_bus_open_user_with_address(bus, address.c_str()); })
 {
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, remote_system_bus_t, const std::string& host)
-    : Connection(std::move(interface), [this, &host](sd_bus** bus){ return iface_->sd_bus_open_system_remote(bus, host.c_str()); })
+    : Connection(std::move(interface), [this, &host](sd_bus** bus){ return sdbus_->sd_bus_open_system_remote(bus, host.c_str()); })
 {
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, private_bus_t, const std::string& address)
-    : Connection(std::move(interface), [&](sd_bus** bus) { return iface_->sd_bus_open_direct(bus, address.c_str()); })
+    : Connection(std::move(interface), [&](sd_bus** bus) { return sdbus_->sd_bus_open_direct(bus, address.c_str()); })
 {
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, private_bus_t, int fd)
-        : Connection(std::move(interface), [&](sd_bus** bus) { return iface_->sd_bus_open_direct(bus, fd); })
+        : Connection(std::move(interface), [&](sd_bus** bus) { return sdbus_->sd_bus_open_direct(bus, fd); })
 {
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, server_bus_t, int fd)
-    : Connection(std::move(interface), [&](sd_bus** bus) { return iface_->sd_bus_open_server(bus, fd); })
+    : Connection(std::move(interface), [&](sd_bus** bus) { return sdbus_->sd_bus_open_server(bus, fd); })
 {
 }

@@ -91,10 +97,10 @@ Connection::Connection(std::unique_ptr<ISdBus>&& interface, sdbus_bus_t, sd_bus
 }

 Connection::Connection(std::unique_ptr<ISdBus>&& interface, pseudo_bus_t)
-    : iface_(std::move(interface))
+    : sdbus_(std::move(interface))
    , bus_(openPseudoBus())
 {
-    assert(iface_ != nullptr);
+    assert(sdbus_ != nullptr);
 }

 Connection::~Connection()
@@ -106,46 +112,42 @@ void Connection::requestName(const std::string& name)
 {
    SDBUS_CHECK_SERVICE_NAME(name);

-    auto r = iface_->sd_bus_request_name(bus_.get(), name.c_str(), 0);
+    auto r = sdbus_->sd_bus_request_name(bus_.get(), name.c_str(), 0);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to request bus name", -r);

    // In some cases we need to explicitly notify the event loop
-    // to process messages that may have arrived while executing the call.
-    notifyEventLoop(eventFd_.fd);
+    // to process messages that may have arrived while executing the call
+    wakeUpEventLoopIfMessagesInQueue();
 }

 void Connection::releaseName(const std::string& name)
 {
-    auto r = iface_->sd_bus_release_name(bus_.get(), name.c_str());
+    auto r = sdbus_->sd_bus_release_name(bus_.get(), name.c_str());
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to release bus name", -r);

    // In some cases we need to explicitly notify the event loop
-    // to process messages that may have arrived while executing the call.
-    notifyEventLoop(eventFd_.fd);
+    // to process messages that may have arrived while executing the call
+    wakeUpEventLoopIfMessagesInQueue();
 }

 std::string Connection::getUniqueName() const
 {
    const char* unique = nullptr;
-    auto r = iface_->sd_bus_get_unique_name(bus_.get(), &unique);
+    auto r = sdbus_->sd_bus_get_unique_name(bus_.get(), &unique);
    SDBUS_THROW_ERROR_IF(r < 0 || unique == nullptr, "Failed to get unique bus name", -r);
    return unique;
 }

 void Connection::enterEventLoop()
 {
-    loopThreadId_ = std::this_thread::get_id();
-    SCOPE_EXIT{ loopThreadId_ = std::thread::id{}; };
-
-    std::lock_guard guard(loopMutex_);
-
    while (true)
    {
-        auto processed = processPendingRequest();
-        if (processed)
-            continue; // Process next one
+        // Process one pending event
+        (void)processPendingEvent();

-        auto success = waitForNextRequest();
+        // And go to poll(), which wakes us up right away
+        // if there's another pending event, or sleeps otherwise.
+        auto success = waitForNextEvent();
        if (!success)
            break; // Exit I/O event loop
    }
@@ -166,48 +168,47 @@ void Connection::leaveEventLoop()
 Connection::PollData Connection::getEventLoopPollData() const
 {
    ISdBus::PollData pollData{};
-    auto r = iface_->sd_bus_get_poll_data(bus_.get(), &pollData);
+    auto r = sdbus_->sd_bus_get_poll_data(bus_.get(), &pollData);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get bus poll data", -r);

-    return {pollData.fd, pollData.events, pollData.timeout_usec};
+    assert(eventFd_.fd >= 0);
+
+    auto timeout = pollData.timeout_usec == UINT64_MAX ? std::chrono::microseconds::max() : std::chrono::microseconds(pollData.timeout_usec);
+
+    return {pollData.fd, pollData.events, timeout, eventFd_.fd};
 }

 const ISdBus& Connection::getSdBusInterface() const
 {
-    return *iface_.get();
+    return *sdbus_.get();
 }

 ISdBus& Connection::getSdBusInterface()
 {
-    return *iface_.get();
-}
-
-void Connection::addObjectManager(const std::string& objectPath)
-{
-    Connection::addObjectManager(objectPath, floating_slot);
+    return *sdbus_.get();
 }

 void Connection::addObjectManager(const std::string& objectPath, floating_slot_t)
 {
-    auto r = iface_->sd_bus_add_object_manager(bus_.get(), nullptr, objectPath.c_str());
+    auto r = sdbus_->sd_bus_add_object_manager(bus_.get(), nullptr, objectPath.c_str());

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add object manager", -r);
 }

-Slot Connection::addObjectManager(const std::string& objectPath, request_slot_t)
+Slot Connection::addObjectManager(const std::string& objectPath, return_slot_t)
 {
    sd_bus_slot *slot{};

-    auto r = iface_->sd_bus_add_object_manager(bus_.get(), &slot, objectPath.c_str());
+    auto r = sdbus_->sd_bus_add_object_manager(bus_.get(), &slot, objectPath.c_str());

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add object manager", -r);

-    return {slot, [this](void *slot){ iface_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
+    return {slot, [this](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }

 void Connection::setMethodCallTimeout(uint64_t timeout)
 {
-    auto r = iface_->sd_bus_set_method_call_timeout(bus_.get(), timeout);
+    auto r = sdbus_->sd_bus_set_method_call_timeout(bus_.get(), timeout);

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set method call timeout", -r);
 }
@@ -216,7 +217,7 @@ uint64_t Connection::getMethodCallTimeout() const
 {
    uint64_t timeout;

-    auto r = iface_->sd_bus_get_method_call_timeout(bus_.get(), &timeout);
+    auto r = sdbus_->sd_bus_get_method_call_timeout(bus_.get(), &timeout);

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get method call timeout", -r);

@@ -229,15 +230,13 @@ Slot Connection::addMatch(const std::string& match, message_handler callback)

    auto matchInfo = std::make_unique<MatchInfo>(MatchInfo{std::move(callback), {}, *this, {}});

-    auto r = iface_->sd_bus_add_match(bus_.get(), &matchInfo->slot, match.c_str(), &Connection::sdbus_match_callback, matchInfo.get());
+    sd_bus_slot *slot{};
+    auto r = sdbus_->sd_bus_add_match(bus_.get(), &slot, match.c_str(), &Connection::sdbus_match_callback, matchInfo.get());
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add match", -r);

-    return {matchInfo.release(), [this](void *ptr)
-    {
-        auto* matchInfo = static_cast<MatchInfo*>(ptr);
-        iface_->sd_bus_slot_unref(matchInfo->slot);
-        std::default_delete<MatchInfo>{}(matchInfo);
-    }};
+    matchInfo->slot = {slot, [this](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
+
+    return {matchInfo.release(), [](void *ptr){ delete static_cast<MatchInfo*>(ptr); }};
 }

 void Connection::addMatch(const std::string& match, message_handler callback, floating_slot_t)
@@ -252,20 +251,18 @@ Slot Connection::addMatchAsync(const std::string& match, message_handler callbac
    sd_bus_message_handler_t sdbusInstallCallback = installCallback ? &Connection::sdbus_match_install_callback : nullptr;
    auto matchInfo = std::make_unique<MatchInfo>(MatchInfo{std::move(callback), std::move(installCallback), *this, {}});

-    auto r = iface_->sd_bus_add_match_async( bus_.get()
-                                           , &matchInfo->slot
+    sd_bus_slot *slot{};
+    auto r = sdbus_->sd_bus_add_match_async( bus_.get()
+                                           , &slot
                                           , match.c_str()
                                           , &Connection::sdbus_match_callback
                                           , sdbusInstallCallback
                                           , matchInfo.get());
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add match", -r);

-    return {matchInfo.release(), [this](void *ptr)
-    {
-        auto* matchInfo = static_cast<MatchInfo*>(ptr);
-        iface_->sd_bus_slot_unref(matchInfo->slot);
-        std::default_delete<MatchInfo>{}(matchInfo);
-    }};
+    matchInfo->slot = {slot, [this](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
+
+    return {matchInfo.release(), [](void *ptr){ delete static_cast<MatchInfo*>(ptr); }};
 }

 void Connection::addMatchAsync(const std::string& match, message_handler callback, message_handler installCallback, floating_slot_t)
@@ -273,6 +270,192 @@ void Connection::addMatchAsync(const std::string& match, message_handler callbac
    floatingMatchRules_.push_back(addMatchAsync(match, std::move(callback), std::move(installCallback)));
 }

+void Connection::attachSdEventLoop(sd_event *event, int priority)
+{
+#ifndef SDBUS_basu
+    auto pollData = getEventLoopPollData();
+
+    auto sdEvent = createSdEventSlot(event);
+    auto sdTimeEventSource = createSdTimeEventSourceSlot(event, priority);
+    auto sdIoEventSource = createSdIoEventSourceSlot(event, pollData.fd, priority);
+    auto sdInternalEventSource = createSdInternalEventSourceSlot(event, pollData.eventFd, priority);
+
+    sdEvent_ = std::make_unique<SdEvent>(SdEvent{ std::move(sdEvent)
+                                                , std::move(sdTimeEventSource)
+                                                , std::move(sdIoEventSource)
+                                                , std::move(sdInternalEventSource) });
+#else
+    (void)event;
+    (void)priority;
+    SDBUS_THROW_ERROR("sd_event integration is not supported on this platform", EOPNOTSUPP);
+#endif
+}
+
+void Connection::detachSdEventLoop()
+{
+    sdEvent_.reset();
+}
+
+sd_event *Connection::getSdEventLoop()
+{
+    return sdEvent_ ? static_cast<sd_event*>(sdEvent_->sdEvent.get()) : nullptr;
+}
+
+#ifndef SDBUS_basu
+
+Slot Connection::createSdEventSlot(sd_event *event)
+{
+    // Get default event if no event is provided by the caller
+    if (event != nullptr)
+        event = sd_event_ref(event);
+    else
+        (void)sd_event_default(&event);
+    SDBUS_THROW_ERROR_IF(!event, "Invalid sd_event handle", EINVAL);
+
+    return Slot{event, [](void* event){ sd_event_unref((sd_event*)event); }};
+}
+
+Slot Connection::createSdTimeEventSourceSlot(sd_event *event, int priority)
+{
+    sd_event_source *timeEventSource{};
+    auto r = sd_event_add_time(event, &timeEventSource, CLOCK_MONOTONIC, 0, 0, onSdTimerEvent, this);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add timer event", -r);
+    Slot sdTimeEventSource{timeEventSource, [](void* source){ deleteSdEventSource((sd_event_source*)source); }};
+
+    r = sd_event_source_set_priority(timeEventSource, priority);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set time event priority", -r);
+
+    r = sd_event_source_set_description(timeEventSource, "bus-time");
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set time event description", -r);
+
+    return sdTimeEventSource;
+}
+
+Slot Connection::createSdIoEventSourceSlot(sd_event *event, int fd, int priority)
+{
+    sd_event_source *ioEventSource{};
+    auto r = sd_event_add_io(event, &ioEventSource, fd, 0, onSdIoEvent, this);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add io event", -r);
+    Slot sdIoEventSource{ioEventSource, [](void* source){ deleteSdEventSource((sd_event_source*)source); }};
+
+    r = sd_event_source_set_prepare(ioEventSource, onSdEventPrepare);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set prepare callback for IO event", -r);
+
+    r = sd_event_source_set_priority(ioEventSource, priority);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set priority for IO event", -r);
+
+    r = sd_event_source_set_description(ioEventSource, "bus-input");
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set priority for IO event", -r);
+
+    return sdIoEventSource;
+}
+
+Slot Connection::createSdInternalEventSourceSlot(sd_event *event, int fd, int priority)
+{
+    sd_event_source *internalEventSource{};
+    auto r = sd_event_add_io(event, &internalEventSource, fd, 0, onSdInternalEvent, this);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to add internal event", -r);
+    Slot sdInternalEventSource{internalEventSource, [](void* source){ deleteSdEventSource((sd_event_source*)source); }};
+
+    // sd-event loop calls prepare callbacks for all event sources, not just for the one that fired now.
+    // So since onSdEventPrepare is already registered on ioEventSource, we don't need to duplicate it here.
+    //r = sd_event_source_set_prepare(internalEventSource, onSdEventPrepare);
+    //SDBUS_THROW_ERROR_IF(r < 0, "Failed to set prepare callback for internal event", -r);
+
+    r = sd_event_source_set_priority(internalEventSource, priority);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set priority for internal event", -r);
+
+    r = sd_event_source_set_description(internalEventSource, "internal-event");
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set priority for IO event", -r);
+
+    return sdInternalEventSource;
+}
+
+int Connection::onSdTimerEvent(sd_event_source */*s*/, uint64_t /*usec*/, void *userdata)
+{
+    auto connection = static_cast<Connection*>(userdata);
+    assert(connection != nullptr);
+
+    (void)connection->processPendingEvent();
+
+    return 1;
+}
+
+int Connection::onSdIoEvent(sd_event_source */*s*/, int /*fd*/, uint32_t /*revents*/, void *userdata)
+{
+    auto connection = static_cast<Connection*>(userdata);
+    assert(connection != nullptr);
+
+    (void)connection->processPendingEvent();
+
+    return 1;
+}
+
+int Connection::onSdInternalEvent(sd_event_source */*s*/, int /*fd*/, uint32_t /*revents*/, void *userdata)
+{
+    auto connection = static_cast<Connection*>(userdata);
+    assert(connection != nullptr);
+
+    // It's not really necessary to processPendingEvent() here. We just clear the event fd.
+    // The sd-event loop will before the next poll call prepare callbacks for all event sources,
+    // including I/O bus fd. This will get up-to-date poll timeout, which will be zero if there
+    // are pending D-Bus messages in the read queue, which will immediately wake up next poll
+    // and go to onSdIoEvent() handler, which calls processPendingEvent(). Viola.
+    // For external event loops that only have access to public sdbus-c++ API, processPendingEvent()
+    // is the only option to clear event fd (it comes at a little extra cost but on the other hand
+    // the solution is simpler for clients -- we don't provide an extra method for just clearing
+    // the event fd. There is one method for both fd's -- and that's processPendingEvent().
+
+    // Kept here so that potential readers know what to do in their custom external event loops.
+    //(void)connection->processPendingEvent();
+
+    connection->eventFd_.clear();
+
+    return 1;
+}
+
+int Connection::onSdEventPrepare(sd_event_source */*s*/, void *userdata)
+{
+    auto connection = static_cast<Connection*>(userdata);
+    assert(connection != nullptr);
+
+    auto sdbusPollData = connection->getEventLoopPollData();
+
+    // Set poll events to watch out for on I/O fd
+    auto* sdIoEventSource = static_cast<sd_event_source*>(connection->sdEvent_->sdIoEventSource.get());
+    auto r = sd_event_source_set_io_events(sdIoEventSource, sdbusPollData.events);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set poll events for IO event source", -r);
+
+    // Set poll events to watch out for on internal event fd
+    auto* sdInternalEventSource = static_cast<sd_event_source*>(connection->sdEvent_->sdInternalEventSource.get());
+    r = sd_event_source_set_io_events(sdInternalEventSource, POLLIN);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set poll events for internal event source", -r);
+
+    // Set current timeout to the time event source (it may be zero if there are messages in the sd-bus queues to be processed)
+    auto* sdTimeEventSource = static_cast<sd_event_source*>(connection->sdEvent_->sdTimeEventSource.get());
+    r = sd_event_source_set_time(sdTimeEventSource, static_cast<uint64_t>(sdbusPollData.timeout.count()));
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to set timeout for time event source", -r);
+    // In case the timeout is infinite, we disable the timer in the sd_event loop.
+    // This prevents a syscall error, where `timerfd_settime` returns `EINVAL`,
+    // because the value is too big. See #324 for details
+    r = sd_event_source_set_enabled(sdTimeEventSource, sdbusPollData.timeout != sdbusPollData.timeout.max() ? SD_EVENT_ONESHOT : SD_EVENT_OFF);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to enable time event source", -r);
+
+    return 1;
+}
+
+void Connection::deleteSdEventSource(sd_event_source *s)
+{
+#if LIBSYSTEMD_VERSION>=243
+    sd_event_source_disable_unref(s);
+#else
+    sd_event_source_set_enabled(s, SD_EVENT_OFF);
+    sd_event_source_unref(s);
+#endif
+}
+
+#endif // SDBUS_basu
+
 Slot Connection::addObjectVTable( const std::string& objectPath
                                , const std::string& interfaceName
                                , const sd_bus_vtable* vtable
@@ -280,7 +463,7 @@ Slot Connection::addObjectVTable( const std::string& objectPath
 {
    sd_bus_slot *slot{};

-    auto r = iface_->sd_bus_add_object_vtable( bus_.get()
+    auto r = sdbus_->sd_bus_add_object_vtable( bus_.get()
                                             , &slot
                                             , objectPath.c_str()
                                             , interfaceName.c_str()
@@ -289,18 +472,18 @@ Slot Connection::addObjectVTable( const std::string& objectPath

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to register object vtable", -r);

-    return {slot, [this](void *slot){ iface_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
+    return {slot, [this](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }

 PlainMessage Connection::createPlainMessage() const
 {
    sd_bus_message* sdbusMsg{};

-    auto r = iface_->sd_bus_message_new(bus_.get(), &sdbusMsg, _SD_BUS_MESSAGE_TYPE_INVALID);
+    auto r = sdbus_->sd_bus_message_new(bus_.get(), &sdbusMsg, _SD_BUS_MESSAGE_TYPE_INVALID);

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create a plain message", -r);

-    return Message::Factory::create<PlainMessage>(sdbusMsg, iface_.get(), adopt_message);
+    return Message::Factory::create<PlainMessage>(sdbusMsg, sdbus_.get(), adopt_message);
 }

 MethodCall Connection::createMethodCall( const std::string& destination
@@ -310,7 +493,7 @@ MethodCall Connection::createMethodCall( const std::string& destination
 {
    sd_bus_message *sdbusMsg{};

-    auto r = iface_->sd_bus_message_new_method_call( bus_.get()
+    auto r = sdbus_->sd_bus_message_new_method_call( bus_.get()
                                                   , &sdbusMsg
                                                   , destination.empty() ? nullptr : destination.c_str()
                                                   , objectPath.c_str()
@@ -319,7 +502,7 @@ MethodCall Connection::createMethodCall( const std::string& destination

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create method call", -r);

-    return Message::Factory::create<MethodCall>(sdbusMsg, iface_.get(), this, adopt_message);
+    return Message::Factory::create<MethodCall>(sdbusMsg, sdbus_.get(), adopt_message);
 }

 Signal Connection::createSignal( const std::string& objectPath
@@ -328,7 +511,7 @@ Signal Connection::createSignal( const std::string& objectPath
 {
    sd_bus_message *sdbusMsg{};

-    auto r = iface_->sd_bus_message_new_signal( bus_.get()
+    auto r = sdbus_->sd_bus_message_new_signal( bus_.get()
                                              , &sdbusMsg
                                              , objectPath.c_str()
                                              , interfaceName.c_str()
@@ -336,7 +519,47 @@ Signal Connection::createSignal( const std::string& objectPath

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to create signal", -r);

-    return Message::Factory::create<Signal>(sdbusMsg, iface_.get(), adopt_message);
+    return Message::Factory::create<Signal>(sdbusMsg, sdbus_.get(), adopt_message);
+}
+
+MethodReply Connection::callMethod(const MethodCall& message, uint64_t timeout)
+{
+    // If the call expects reply, this call will block the bus connection from
+    // serving other messages until the reply arrives or the call times out.
+    auto reply = message.send(timeout);
+
+    // Wake up event loop to process messages that may have arrived in the meantime...
+    wakeUpEventLoopIfMessagesInQueue();
+
+    return reply;
+}
+
+void Connection::callMethod(const MethodCall& message, void* callback, void* userData, uint64_t timeout, floating_slot_t)
+{
+    // TODO: Think of ways of optimizing these three locking/unlocking of sdbus mutex (merge into one call?)
+    auto timeoutBefore = getEventLoopPollData().timeout;
+    message.send(callback, userData, timeout, floating_slot);
+    auto timeoutAfter = getEventLoopPollData().timeout;
+
+    // An event loop may wait in poll with timeout `t1', while in another thread an async call is made with
+    // timeout `t2'. If `t2' < `t1', then we have to wake up the event loop thread to update its poll timeout.
+    if (timeoutAfter < timeoutBefore)
+        notifyEventLoopToWakeUpFromPoll();
+}
+
+Slot Connection::callMethod(const MethodCall& message, void* callback, void* userData, uint64_t timeout)
+{
+    // TODO: Think of ways of optimizing these three locking/unlocking of sdbus mutex (merge into one call?)
+    auto timeoutBefore = getEventLoopPollData().timeout;
+    auto slot = message.send(callback, userData, timeout);
+    auto timeoutAfter = getEventLoopPollData().timeout;
+
+    // An event loop may wait in poll with timeout `t1', while in another thread an async call is made with
+    // timeout `t2'. If `t2' < `t1', then we have to wake up the event loop thread to update its poll timeout.
+    if (timeoutAfter < timeoutBefore)
+        notifyEventLoopToWakeUpFromPoll();
+
+    return slot;
 }

 void Connection::emitPropertiesChangedSignal( const std::string& objectPath
@@ -345,7 +568,7 @@ void Connection::emitPropertiesChangedSignal( const std::string& objectPath
 {
    auto names = to_strv(propNames);

-    auto r = iface_->sd_bus_emit_properties_changed_strv( bus_.get()
+    auto r = sdbus_->sd_bus_emit_properties_changed_strv( bus_.get()
                                                        , objectPath.c_str()
                                                        , interfaceName.c_str()
                                                        , propNames.empty() ? nullptr : &names[0] );
@@ -355,7 +578,7 @@ void Connection::emitPropertiesChangedSignal( const std::string& objectPath

 void Connection::emitInterfacesAddedSignal(const std::string& objectPath)
 {
-    auto r = iface_->sd_bus_emit_object_added(bus_.get(), objectPath.c_str());
+    auto r = sdbus_->sd_bus_emit_object_added(bus_.get(), objectPath.c_str());

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit InterfacesAdded signal for all registered interfaces", -r);
 }
@@ -365,7 +588,7 @@ void Connection::emitInterfacesAddedSignal( const std::string& objectPath
 {
    auto names = to_strv(interfaces);

-    auto r = iface_->sd_bus_emit_interfaces_added_strv( bus_.get()
+    auto r = sdbus_->sd_bus_emit_interfaces_added_strv( bus_.get()
                                                      , objectPath.c_str()
                                                      , interfaces.empty() ? nullptr : &names[0] );

@@ -374,7 +597,7 @@ void Connection::emitInterfacesAddedSignal( const std::string& objectPath

 void Connection::emitInterfacesRemovedSignal(const std::string& objectPath)
 {
-    auto r = iface_->sd_bus_emit_object_removed(bus_.get(), objectPath.c_str());
+    auto r = sdbus_->sd_bus_emit_object_removed(bus_.get(), objectPath.c_str());

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to emit InterfacesRemoved signal for all registered interfaces", -r);
 }
@@ -384,7 +607,7 @@ void Connection::emitInterfacesRemovedSignal( const std::string& objectPath
 {
    auto names = to_strv(interfaces);

-    auto r = iface_->sd_bus_emit_interfaces_removed_strv( bus_.get()
+    auto r = sdbus_->sd_bus_emit_interfaces_removed_strv( bus_.get()
                                                        , objectPath.c_str()
                                                        , interfaces.empty() ? nullptr : &names[0] );

@@ -400,44 +623,18 @@ Slot Connection::registerSignalHandler( const std::string& sender
 {
    sd_bus_slot *slot{};

-    // Alternatively to our own composeSignalMatchFilter() implementation, we could use sd_bus_match_signal() from
-    // https://www.freedesktop.org/software/systemd/man/sd_bus_add_match.html .
-    // But this would require libsystemd v237 or higher.
-    auto filter = composeSignalMatchFilter(sender, objectPath, interfaceName, signalName);
-    auto r = iface_->sd_bus_add_match(bus_.get(), &slot, filter.c_str(), callback, userData);
+    auto r = sdbus_->sd_bus_match_signal( bus_.get()
+                                        , &slot
+                                        , !sender.empty() ? sender.c_str() : nullptr
+                                        , !objectPath.empty() ? objectPath.c_str() : nullptr
+                                        , !interfaceName.empty() ? interfaceName.c_str() : nullptr
+                                        , !signalName.empty() ? signalName.c_str() : nullptr
+                                        , callback
+                                        , userData );

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to register signal handler", -r);

-    return {slot, [this](void *slot){ iface_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
-}
-
-MethodReply Connection::tryCallMethodSynchronously(const MethodCall& message, uint64_t timeout)
-{
-    auto loopThreadId = loopThreadId_.load(std::memory_order_relaxed);
-
-    // Is the loop not yet on? => Go make synchronous call
-    while (loopThreadId == std::thread::id{})
-    {
-        // Did the loop begin in the meantime? Or try_lock() failed spuriously?
-        if (!loopMutex_.try_lock())
-        {
-            loopThreadId = loopThreadId_.load(std::memory_order_relaxed);
-            continue;
-        }
-
-        // Synchronous D-Bus call
-        std::lock_guard guard(loopMutex_, std::adopt_lock);
-        return message.send(timeout);
-    }
-
-    // Is the loop on and we are in the same thread? => Go for synchronous call
-    if (loopThreadId == std::this_thread::get_id())
-    {
-        assert(!loopMutex_.try_lock());
-        return message.send(timeout);
-    }
-
-    return {};
+    return {slot, [this](void *slot){ sdbus_->sd_bus_slot_unref((sd_bus_slot*)slot); }};
 }

 Connection::BusPtr Connection::openBus(const BusFactory& busFactory)
@@ -446,7 +643,7 @@ Connection::BusPtr Connection::openBus(const BusFactory& busFactory)
    int r = busFactory(&bus);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to open bus", -r);

-    BusPtr busPtr{bus, [this](sd_bus* bus){ return iface_->sd_bus_flush_close_unref(bus); }};
+    BusPtr busPtr{bus, [this](sd_bus* bus){ return sdbus_->sd_bus_flush_close_unref(bus); }};
    finishHandshake(busPtr.get());
    return busPtr;
 }
@@ -455,17 +652,17 @@ Connection::BusPtr Connection::openPseudoBus()
 {
    sd_bus* bus{};

-    int r = iface_->sd_bus_new(&bus);
+    int r = sdbus_->sd_bus_new(&bus);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to open pseudo bus", -r);

-    (void)iface_->sd_bus_start(bus);
+    (void)sdbus_->sd_bus_start(bus);
    // It is expected that sd_bus_start has failed here, returning -EINVAL, due to having
    // not set a bus address, but it will leave the bus in an OPENING state, which enables
    // us to create plain D-Bus messages as a local data storage (for Variant, for example),
    // without dependency on real IPC communication with the D-Bus broker daemon.
    SDBUS_THROW_ERROR_IF(r < 0 && r != -EINVAL, "Failed to start pseudo bus", -r);

-    return {bus, [this](sd_bus* bus){ return iface_->sd_bus_close_unref(bus); }};
+    return {bus, [this](sd_bus* bus){ return sdbus_->sd_bus_close_unref(bus); }};
 }

 void Connection::finishHandshake(sd_bus* bus)
@@ -476,43 +673,29 @@ void Connection::finishHandshake(sd_bus* bus)

    assert(bus != nullptr);

-    auto r = iface_->sd_bus_flush(bus);
+    auto r = sdbus_->sd_bus_flush(bus);

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to flush bus on opening", -r);
 }

-void Connection::notifyEventLoop(int fd) const
+void Connection::notifyEventLoopToExit()
 {
-    assert(fd >= 0);
-
-    uint64_t value = 1;
-    auto r = write(fd, &value, sizeof(value));
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to notify event loop", -errno);
+    loopExitFd_.notify();
 }

-void Connection::notifyEventLoopToExit() const
+void Connection::notifyEventLoopToWakeUpFromPoll()
 {
-    notifyEventLoop(loopExitFd_.fd);
+    eventFd_.notify();
 }

-void Connection::notifyEventLoopNewTimeout() const
+void Connection::wakeUpEventLoopIfMessagesInQueue()
 {
-    // The extra notifications for new timeouts are only needed if calls are made asynchronously to the event loop.
-    // Are we in the same thread as the event loop? Note that it's ok to fail this check because the event loop isn't yet started.
-    if (loopThreadId_.load(std::memory_order_relaxed) == std::this_thread::get_id())
-        return;
-
-    // Get the new timeout from sd-bus
-    auto sdbusPollData = getEventLoopPollData();
-    if (sdbusPollData.timeout_usec < activeTimeout_.load(std::memory_order_relaxed))
-        notifyEventLoop(eventFd_.fd);
-}
-
-void Connection::clearEventLoopNotification(int fd) const
-{
-    uint64_t value{};
-    auto r = read(fd, &value, sizeof(value));
-    SDBUS_THROW_ERROR_IF(r < 0, "Failed to read from the event descriptor", -errno);
+    // When doing a sync call, other D-Bus messages may have arrived, waiting in the read queue.
+    // In case an event loop is inside a poll in another thread, or an external event loop polls in the
+    // same thread but as an unrelated event source, then we need to wake up the poll explicitly so the
+    // event loop 1. processes all messages in the read queue, 2. updates poll timeout before next poll.
+    if (arePendingMessagesInReadQueue())
+        notifyEventLoopToWakeUpFromPoll();
 }

 void Connection::joinWithEventLoop()
@@ -521,32 +704,36 @@ void Connection::joinWithEventLoop()
        asyncLoopThread_.join();
 }

-bool Connection::processPendingRequest()
+bool Connection::processPendingEvent()
 {
    auto bus = bus_.get();
    assert(bus != nullptr);

-    int r = iface_->sd_bus_process(bus, nullptr);
+    int r = sdbus_->sd_bus_process(bus, nullptr);
    SDBUS_THROW_ERROR_IF(r < 0, "Failed to process bus requests", -r);

+    // In correct use of sdbus-c++ API, r can be 0 only when processPendingEvent()
+    // is called from an external event loop as a reaction to event fd being signalled.
+    // If there are no more D-Bus messages to process, we know we have to clear event fd.
+    if (r == 0)
+        eventFd_.clear();
+
    return r > 0;
 }

-bool Connection::waitForNextRequest()
+bool Connection::waitForNextEvent()
 {
    assert(bus_ != nullptr);
+    assert(loopExitFd_.fd >= 0);
    assert(eventFd_.fd >= 0);

    auto sdbusPollData = getEventLoopPollData();
-    struct pollfd fds[] = {
-            {sdbusPollData.fd, sdbusPollData.events, 0},
-            {eventFd_.fd, POLLIN, 0},
-            {loopExitFd_.fd, POLLIN, 0}
-    };
-    auto fdsCount = sizeof(fds)/sizeof(fds[0]);
+    struct pollfd fds[] = { {sdbusPollData.fd, sdbusPollData.events, 0}
+                          , {eventFd_.fd, POLLIN, 0}
+                          , {loopExitFd_.fd, POLLIN, 0} };
+    constexpr auto fdsCount = sizeof(fds)/sizeof(fds[0]);

    auto timeout = sdbusPollData.getPollTimeout();
-    activeTimeout_.store(sdbusPollData.timeout_usec, std::memory_order_relaxed);
    auto r = poll(fds, fdsCount, timeout);

    if (r < 0 && errno == EINTR)
@@ -554,36 +741,40 @@ bool Connection::waitForNextRequest()

    SDBUS_THROW_ERROR_IF(r < 0, "Failed to wait on the bus", -errno);

-    // new timeout notification
+    // Wake up notification, in order that we re-enter poll with freshly read PollData (namely, new poll timeout thereof)
    if (fds[1].revents & POLLIN)
    {
-        clearEventLoopNotification(fds[1].fd);
+        auto cleared = eventFd_.clear();
+        SDBUS_THROW_ERROR_IF(!cleared, "Failed to read from the event descriptor", -errno);
+        // Go poll() again, but with up-to-date timeout (which will wake poll() up right away if there are messages to process)
+        return waitForNextEvent();
    }
-    // loop exit notification
+    // Loop exit notification
    if (fds[2].revents & POLLIN)
    {
-        clearEventLoopNotification(fds[2].fd);
+        auto cleared = loopExitFd_.clear();
+        SDBUS_THROW_ERROR_IF(!cleared, "Failed to read from the loop exit descriptor", -errno);
        return false;
    }

    return true;
 }

-std::string Connection::composeSignalMatchFilter( const std::string &sender
-                                                , const std::string &objectPath
-                                                , const std::string &interfaceName
-                                                , const std::string &signalName )
+bool Connection::arePendingMessagesInReadQueue() const
 {
-    std::string filter;
+    uint64_t readQueueSize{};

-    filter += "type='signal',";
-    if (!sender.empty())
-        filter += "sender='" + sender + "',";
-    filter += "interface='" + interfaceName + "',";
-    filter += "member='" + signalName + "',";
-    filter += "path='" + objectPath + "'";
+    auto r = sdbus_->sd_bus_get_n_queued_read(bus_.get(), &readQueueSize);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to get number of pending messages in read queue", -r);

-    return filter;
+    return readQueueSize > 0;
+}
+
+Message Connection::getCurrentlyProcessedMessage() const
+{
+    auto* sdbusMsg = sdbus_->sd_bus_get_current_message(bus_.get());
+
+    return Message::Factory::create<Message>(sdbusMsg, sdbus_.get());
 }

 std::vector</*const */char*> Connection::to_strv(const std::vector<std::string>& strings)
@@ -598,16 +789,26 @@ std::vector</*const */char*> Connection::to_strv(const std::vector<std::string>&
 int Connection::sdbus_match_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
 {
    auto* matchInfo = static_cast<MatchInfo*>(userData);
+    assert(matchInfo != nullptr);
+    assert(matchInfo->callback);
+
    auto message = Message::Factory::create<PlainMessage>(sdbusMessage, &matchInfo->connection.getSdBusInterface());
-    auto ok = invokeHandlerAndCatchErrors([&](){ matchInfo->callback(message); }, retError);
+
+    auto ok = invokeHandlerAndCatchErrors([&](){ matchInfo->callback(std::move(message)); }, retError);
+
    return ok ? 0 : -1;
 }

 int Connection::sdbus_match_install_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
 {
    auto* matchInfo = static_cast<MatchInfo*>(userData);
+    assert(matchInfo != nullptr);
+    assert(matchInfo->installCallback);
+
    auto message = Message::Factory::create<PlainMessage>(sdbusMessage, &matchInfo->connection.getSdBusInterface());
-    auto ok = invokeHandlerAndCatchErrors([&](){ matchInfo->installCallback(message); }, retError);
+
+    auto ok = invokeHandlerAndCatchErrors([&](){ matchInfo->installCallback(std::move(message)); }, retError);
+
    return ok ? 0 : -1;
 }

@@ -623,47 +824,54 @@ Connection::EventFd::~EventFd()
    close(fd);
 }

+void Connection::EventFd::notify()
+{
+    assert(fd >= 0);
+    auto r = eventfd_write(fd, 1);
+    SDBUS_THROW_ERROR_IF(r < 0, "Failed to notify event descriptor", -errno);
+}
+
+bool Connection::EventFd::clear()
+{
+    assert(fd >= 0);
+
+    uint64_t value{};
+    auto r = eventfd_read(fd, &value);
+    return r >= 0;
+}
+
 } // namespace sdbus::internal

 namespace sdbus {

-std::optional<std::chrono::microseconds> IConnection::PollData::getRelativeTimeout() const
+std::chrono::microseconds IConnection::PollData::getRelativeTimeout() const
 {
    constexpr auto zero = std::chrono::microseconds::zero();
-    if (timeout_usec == 0)
-        return zero;
-    else if (timeout_usec == UINT64_MAX)
-        return std::nullopt;
+    constexpr auto max = std::chrono::microseconds::max();
+    using internal::now;

-    // We need C so that we use the same clock as the underlying sd-bus lib.
-    // We use POSIX's clock_gettime in favour of std::chrono::steady_clock to ensure this.
-    struct timespec ts{};
-    auto r = clock_gettime(CLOCK_MONOTONIC, &ts);
-    SDBUS_THROW_ERROR_IF(r < 0, "clock_gettime failed: ", -errno);
-    auto now = std::chrono::nanoseconds(ts.tv_nsec) + std::chrono::seconds(ts.tv_sec);
-    auto absTimeout = std::chrono::microseconds(timeout_usec);
-    auto result = std::chrono::duration_cast<std::chrono::microseconds>(absTimeout - now);
-    return std::max(result, zero);
+    if (timeout == zero)
+        return zero;
+    else if (timeout == max)
+        return max;
+    else
+        return std::max(std::chrono::duration_cast<std::chrono::microseconds>(timeout - now()), zero);
 }

 int IConnection::PollData::getPollTimeout() const
 {
-    auto timeout = getRelativeTimeout();
-    return timeout ? static_cast<int>(std::chrono::ceil<std::chrono::milliseconds>(timeout.value()).count()) : -1;
+    const auto relativeTimeout = getRelativeTimeout();
+
+    if (relativeTimeout == decltype(relativeTimeout)::max())
+        return -1;
+    else
+        return static_cast<int>(std::chrono::ceil<std::chrono::milliseconds>(relativeTimeout).count());
 }

 } // namespace sdbus

 namespace sdbus::internal {

-std::unique_ptr<sdbus::internal::IConnection> createConnection()
-{
-    auto connection = sdbus::createConnection();
-    SCOPE_EXIT{ connection.release(); };
-    auto connectionInternal = dynamic_cast<sdbus::internal::IConnection*>(connection.get());
-    return std::unique_ptr<sdbus::internal::IConnection>(connectionInternal);
-}
-
 std::unique_ptr<sdbus::internal::IConnection> createPseudoConnection()
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
@@ -676,25 +884,15 @@ namespace sdbus {

 using internal::Connection;

-std::unique_ptr<sdbus::IConnection> createConnection()
-{
-    return createSystemBusConnection();
-}
-
-std::unique_ptr<sdbus::IConnection> createConnection(const std::string& name)
-{
-    return createSystemBusConnection(name);
-}
-
-std::unique_ptr<sdbus::IConnection> createDefaultBusConnection()
+std::unique_ptr<sdbus::IConnection> createBusConnection()
 {
    auto interface = std::make_unique<sdbus::internal::SdBus>();
    return std::make_unique<sdbus::internal::Connection>(std::move(interface), Connection::default_bus);
 }

-std::unique_ptr<sdbus::IConnection> createDefaultBusConnection(const std::string& name)
+std::unique_ptr<sdbus::IConnection> createBusConnection(const std::string& name)
 {
-    auto conn = createDefaultBusConnection();
+    auto conn = createBusConnection();
    conn->requestName(name);
    return conn;
 }
@@ -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 SDBUS_HEADER
+#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 {

@@ -80,41 +83,49 @@ namespace sdbus::internal {

        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
@@ -133,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*)>>;
@@ -143,27 +152,41 @@ 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:
+#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};
        };

@@ -172,19 +195,26 @@ namespace sdbus::internal {
            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
    };

 }
@@ -24,10 +24,12 @@
 * along with sdbus-c++. If not, see <http://www.gnu.org/licenses/>.
 */

-#include <sdbus-c++/Error.h>
-#include SDBUS_HEADER
+#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
@@ -27,11 +27,14 @@
 #ifndef SDBUS_CXX_INTERNAL_ICONNECTION_H_
 #define SDBUS_CXX_INTERNAL_ICONNECTION_H_

-#include <sdbus-c++/IConnection.h>
-#include SDBUS_HEADER
-#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();

 }
@@ -81,14 +81,16 @@ namespace sdbus::internal {
        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;
@@ -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 SDBUS_HEADER
+
 #include <cassert>
+#include SDBUS_HEADER

 namespace sdbus {

@@ -763,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()
@@ -816,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
@@ -838,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); }};
 }

@@ -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();
@@ -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 <cassert>
 #include SDBUS_HEADER
 #include <utility>
-#include <cassert>

 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,22 +308,17 @@ 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([&](){ callback(message); }, retError);
+    auto ok = invokeHandlerAndCatchErrors([&](){ methodItem->callback(std::move(message)); }, retError);

    return ok ? 1 : -1;
 }
@@ -360,21 +331,23 @@ 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());

-    auto ok = invokeHandlerAndCatchErrors([&](){ callback(reply); }, retError);
+    auto ok = invokeHandlerAndCatchErrors([&](){ propertyItem->getCallback(reply); }, retError);

    return ok ? 1 : -1;
 }
@@ -387,22 +360,17 @@ 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([&](){ callback(value); }, retError);
+    auto ok = invokeHandlerAndCatchErrors([&](){ propertyItem->setCallback(std::move(value)); }, retError);

    return ok ? 1 : -1;
 }
@@ -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 SDBUS_HEADER
-#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};
    };

 }
@@ -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 SDBUS_HEADER
+#include "Utils.h"
+
 #include <cassert>
-#include <chrono>
+#include SDBUS_HEADER
 #include <utility>

 namespace sdbus::internal {
@@ -88,170 +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), {}, AsyncCalls::CallData::State::RUNNING});
+    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);

    pendingAsyncCalls_.addCall(std::move(callData));

+    // TODO: Instead of PendingAsyncCall consider using Slot implementation for simplicity and consistency
    return {weakData};
 }

-std::future<MethodReply> Proxy::callMethod(const MethodCall& message, with_future_t)
+std::future<MethodReply> Proxy::callMethodAsync(const MethodCall& message, with_future_t)
 {
-    return Proxy::callMethod(message, {}, with_future);
+    return Proxy::callMethodAsync(message, {}, with_future);
 }

-std::future<MethodReply> Proxy::callMethod(const MethodCall& message, uint64_t timeout, with_future_t)
+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, const Error* error) noexcept
+    async_reply_handler asyncReplyCallback = [promise = std::move(promise)](MethodReply reply, std::optional<Error> error) noexcept
    {
-        if (error == nullptr)
-            promise->set_value(reply);
+        if (!error)
+            promise->set_value(std::move(reply));
        else
-            promise->set_exception(std::make_exception_ptr(*error));
+            promise->set_exception(std::make_exception_ptr(*std::move(error)));
    };

-    (void)Proxy::callMethod(message, std::move(asyncReplyCallback), timeout);
+    (void)Proxy::callMethodAsync(message, std::move(asyncReplyCallback), timeout);

    return future;
 }

-MethodReply Proxy::sendMethodCallMessageAndWaitForReply(const MethodCall& message, uint64_t timeout)
-{
-    /*thread_local*/ SyncCallReplyData syncCallReplyData;
-
-    async_reply_handler asyncReplyCallback = [&syncCallReplyData](MethodReply& reply, const Error* error)
-    {
-        syncCallReplyData.sendMethodReplyToWaitingThread(reply, error);
-    };
-    auto callback = (void*)&Proxy::sdbus_async_reply_handler;
-    AsyncCalls::CallData callData{*this, std::move(asyncReplyCallback), {}, AsyncCalls::CallData::State::NOT_ASYNC};
-
-    message.send(callback, &callData, timeout, floating_slot);
-
-    return syncCallReplyData.waitForMethodReply();
-}
-
-void Proxy::SyncCallReplyData::sendMethodReplyToWaitingThread(MethodReply& reply, const Error* error)
-{
-    std::unique_lock lock{mutex_};
-    SCOPE_EXIT{ cond_.notify_one(); }; // This must happen before unlocking the mutex to avoid potential data race on spurious wakeup in the waiting thread
-    SCOPE_EXIT{ arrived_ = true; };
-
-    //error_ = nullptr; // Necessary if SyncCallReplyData instance is thread_local
-
-    if (error == nullptr)
-        reply_ = std::move(reply);
-    else
-        error_ = std::make_unique<Error>(*error);
-}
-
-MethodReply Proxy::SyncCallReplyData::waitForMethodReply()
-{
-    std::unique_lock lock{mutex_};
-    cond_.wait(lock, [this](){ return arrived_; });
-
-    //arrived_ = false; // Necessary if SyncCallReplyData instance is thread_local
-
-    if (error_)
-        throw *error_;
-
-    return std::move(reply_);
-}
-
 void Proxy::registerSignalHandler( const std::string& interfaceName
                                 , const std::string& signalName
                                 , signal_handler signalHandler )
+{
+    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
@@ -264,9 +180,9 @@ 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)
@@ -275,37 +191,28 @@ int Proxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userDat
    assert(asyncCallData != nullptr);
    assert(asyncCallData->callback);
    auto& proxy = asyncCallData->proxy;
-    auto state = asyncCallData->state;

    // 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 STATE_NOT_ASYNC)
-        if (state != AsyncCalls::CallData::State::NOT_ASYNC)
-            proxy.pendingAsyncCalls_.removeCall(asyncCallData);
+        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);
-    };
-
    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));
        }
    }, retError);

@@ -314,19 +221,14 @@ int Proxy::sdbus_async_reply_handler(sd_bus_message *sdbusMessage, void *userDat

 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([&](){ signalData->callback(message); }, retError);
+    auto ok = invokeHandlerAndCatchErrors([&](){ signalInfo->callback(std::move(message)); }, retError);

    return ok ? 0 : -1;
 }
@@ -408,7 +310,7 @@ std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<IConnection>&& conne
 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);
@@ -422,7 +324,7 @@ std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
                                          , std::string objectPath
                                          , dont_run_event_loop_thread_t )
 {
-    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);
@@ -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 SDBUS_HEADER
-#include <string>
-#include <memory>
-#include <map>
+
 #include <deque>
+#include <memory>
 #include <mutex>
-#include <atomic>
-#include <condition_variable>
+#include <string>
+#include SDBUS_HEADER
+#include <vector>

 namespace sdbus::internal {

@@ -57,42 +57,26 @@ namespace sdbus::internal {

        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;
-        std::future<MethodReply> callMethod(const MethodCall& message, with_future_t) override;
-        std::future<MethodReply> callMethod(const MethodCall& message, uint64_t timeout, with_future_t) 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;
@@ -103,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
@@ -135,16 +105,10 @@ namespace sdbus::internal {
        public:
            struct CallData
            {
-                enum class State
-                {   NOT_ASYNC
-                ,   RUNNING
-                ,   FINISHED
-                };
-
                Proxy& proxy;
                async_reply_handler callback;
-                Slot slot;
-                State state;
+                Slot slot{};
+                bool finished{false};
            };

            ~AsyncCalls()
@@ -155,14 +119,14 @@ namespace sdbus::internal {
            void addCall(std::shared_ptr<CallData> asyncCallData)
            {
                std::lock_guard lock(mutex_);
-                if (asyncCallData->state != CallData::State::FINISHED) // The call may have finished in the meantime
+                if (!asyncCallData->finished) // The call may have finished in the meantime
                    calls_.emplace_back(std::move(asyncCallData));
            }

            void removeCall(CallData* data)
            {
                std::unique_lock lock(mutex_);
-                data->state = CallData::State::FINISHED;
+                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);
@@ -193,8 +157,6 @@ namespace sdbus::internal {
            std::mutex mutex_;
            std::deque<std::shared_ptr<CallData>> calls_;
        } pendingAsyncCalls_;
-
-        std::atomic<const Message*> m_CurrentlyProcessedMessage{nullptr};
    };

 }
@@ -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.
@@ -53,6 +53,8 @@ int SdBus::sd_bus_send(sd_bus *bus, sd_bus_message *m, uint64_t *cookie)
        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;
@@ -74,6 +76,8 @@ int SdBus::sd_bus_call_async(sd_bus *bus, sd_bus_slot **slot, sd_bus_message *m,
      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;
@@ -296,11 +300,13 @@ int SdBus::sd_bus_open_server(sd_bus **ret, int fd)

 int SdBus::sd_bus_open_system_remote(sd_bus **ret, const char *host)
 {
-#ifdef SDBUS_basu
+#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;
-#else
-    return ::sd_bus_open_system_remote(ret, host);
 #endif
 }

@@ -352,6 +358,13 @@ int SdBus::sd_bus_add_match_async(sd_bus *bus, sd_bus_slot **slot, const char *m
    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)
 {
    std::lock_guard lock(sdbusMutex_);
@@ -376,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_);
@@ -395,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);
@@ -73,14 +73,16 @@ public:
    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;
@@ -24,13 +24,15 @@
 * 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 SDBUS_HEADER
-#include <cassert>
+
 #include <cerrno>
 #include <system_error>
+#include SDBUS_HEADER
 #include <unistd.h>

 namespace sdbus {
@@ -67,7 +69,7 @@ bool Variant::isEmpty() const
    return msg_.isEmpty();
 }

-void UnixFd::close()
+void UnixFd::close() // NOLINT(readability-make-member-function-const)
 {
    if (fd_ >= 0)
    {
@@ -82,7 +84,7 @@ int UnixFd::checkedDup(int fd)
        return fd;
    }

-    int ret = ::dup(fd);
+    int ret = ::dup(fd); // NOLINT(android-cloexec-dup) // TODO: verify
    if (ret < 0)
    {
        throw std::system_error(errno, std::generic_category(), "dup failed");
@@ -90,4 +92,4 @@ int UnixFd::checkedDup(int fd)
    return ret;
 }

-}
+} // namespace sdbus
@@ -78,6 +78,17 @@ namespace sdbus::internal {
        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...>;
@@ -27,18 +27,18 @@
 #include "VTableUtils.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;
@@ -27,34 +27,34 @@
 #ifndef SDBUS_CXX_INTERNAL_VTABLEUTILS_H_
 #define SDBUS_CXX_INTERNAL_VTABLEUTILS_H_

-#include SDBUS_HEADER
 #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
 }
@@ -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
@@ -105,23 +103,28 @@ 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}
+    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)
@@ -129,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)
@@ -140,25 +143,25 @@ endif()
 # INSTALLATION
 #----------------------------------

-option(INSTALL_TESTS "Install tests (default OFF)" OFF)
-
-if(INSTALL_TESTS)
+if(SDBUSCPP_INSTALL)
    include(GNUInstallDirs)
-    set(TESTS_INSTALL_PATH "tests/${PROJECT_NAME}" 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 ${CMAKE_INSTALL_FULL_SYSCONFDIR}/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 ${CMAKE_INSTALL_FULL_SYSCONFDIR}/dbus-1/system.d COMPONENT test)
+    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(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 ${CMAKE_INSTALL_FULL_SYSCONFDIR}/dbus-1/system.d COMPONENT test)
+    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()

@@ -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,33 +142,33 @@ 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, InvokesMethodAsynchronouslyOnClientSideWithFuture)
+TYPED_TEST(AsyncSdbusTestObject, InvokesMethodAsynchronouslyOnClientSideWithFuture)
 {
-    auto future = m_proxy->doOperationClientSideAsync(100, sdbus::with_future);
+    auto future = this->m_proxy->doOperationClientSideAsync(100, sdbus::with_future);

    ASSERT_THAT(future.get(), Eq(100));
 }

-TEST_F(SdbusTestObject, InvokesMethodAsynchronouslyOnClientSideWithFutureOnBasicAPILevel)
+TYPED_TEST(AsyncSdbusTestObject, InvokesMethodAsynchronouslyOnClientSideWithFutureOnBasicAPILevel)
 {
-    auto future = m_proxy->doOperationClientSideAsyncOnBasicAPILevel(100);
+    auto future = this->m_proxy->doOperationClientSideAsyncOnBasicAPILevel(100);

    auto methodReply = future.get();
    uint32_t returnValue{};
@@ -179,87 +177,87 @@ TEST_F(SdbusTestObject, InvokesMethodAsynchronouslyOnClientSideWithFutureOnBasic
    ASSERT_THAT(returnValue, Eq(100));
 }

-TEST_F(SdbusTestObject, AnswersThatAsyncCallIsPendingIfItIsInProgress)
+TYPED_TEST(AsyncSdbusTestObject, AnswersThatAsyncCallIsPendingIfItIsInProgress)
 {
-    m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, const sdbus::Error* /*err*/){});
+    this->m_proxy->installDoOperationClientSideAsyncReplyHandler([&](uint32_t /*res*/, std::optional<sdbus::Error> /*err*/){});

-    auto call = m_proxy->doOperationClientSideAsync(100);
+    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, ReturnsNonnullErrorWhenAsynchronousMethodCallFails)
+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);
 }

-TEST_F(SdbusTestObject, ThrowsErrorWhenClientSideAsynchronousMethodCallWithFutureFails)
+TYPED_TEST(AsyncSdbusTestObject, ThrowsErrorWhenClientSideAsynchronousMethodCallWithFutureFails)
 {
-    auto future = m_proxy->doErroneousOperationClientSideAsync(sdbus::with_future);
+    auto future = this->m_proxy->doErroneousOperationClientSideAsync(sdbus::with_future);

    ASSERT_THROW(future.get(), sdbus::Error);
 }
@@ -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);
-}
@@ -45,7 +45,6 @@ using ::testing::Eq;
 using namespace std::chrono_literals;
 using namespace sdbus::test;

-using AConnection = TestFixture;
 using ADirectConnection = TestFixtureWithDirectConnection;

 /*-------------------------------------*/
@@ -54,7 +53,7 @@ using ADirectConnection = TestFixtureWithDirectConnection;

 TEST(AdaptorAndProxy, CanBeConstructedSuccesfully)
 {
-    auto connection = sdbus::createConnection();
+    auto connection = sdbus::createBusConnection();
    connection->requestName(BUS_NAME);

    ASSERT_NO_THROW(TestAdaptor adaptor(*connection, OBJECT_PATH));
@@ -73,97 +72,97 @@ TEST(AnAdaptor, SupportsMoveSemantics)
    static_assert(std::is_move_assignable_v<DummyTestAdaptor>);
 }

-TEST_F(AConnection, WillCallCallbackHandlerForIncomingMessageMatchingMatchRule)
+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, CanInstallMatchRuleAsynchronously)
+TYPED_TEST(AConnection, CanInstallMatchRuleAsynchronously)
 {
    auto matchRule = "sender='" + BUS_NAME + "',path='" + OBJECT_PATH + "'";
    std::atomic<bool> matchingMessageReceived{false};
    std::atomic<bool> matchRuleInstalled{false};
-    auto slot = s_proxyConnection->addMatchAsync( matchRule
-                                                , [&](sdbus::Message& msg)
-                                                  {
-                                                      if(msg.getPath() == OBJECT_PATH)
-                                                          matchingMessageReceived = true;
-                                                  }
-                                                , [&](sdbus::Message& /*msg*/)
-                                                  {
-                                                      matchRuleInstalled = true;
-                                                  } );
+    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));

-    m_adaptor->emitSimpleSignal();
+    this->m_adaptor->emitSimpleSignal();

    ASSERT_TRUE(waitUntil(matchingMessageReceived));
 }

-TEST_F(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedSlot)
+TYPED_TEST(AConnection, WillUnsubscribeMatchRuleWhenClientDestroysTheAssociatedSlot)
 {
    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;
    });
    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();
+    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));
@@ -50,59 +50,56 @@ 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);
+    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}}};
@@ -112,69 +109,69 @@ TEST_F(SdbusTestObject, CallsMethodWithStructVariantsAndGetMapSuccesfully)
    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->sumArrayItems({1, 7}, {2, 3, 4});
+    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)
@@ -190,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)
@@ -208,82 +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

-TEST_F(SdbusTestObject, CanCallMethodSynchronouslyWithoutAnEventLoopThread)
+TYPED_TEST(SdbusTestObject, CanCallMethodSynchronouslyWithoutAnEventLoopThread)
 {
-#if defined(__clang__) && defined(__FreeBSD__)
-    GTEST_SKIP() << "https://github.com/Kistler-Group/sdbus-cpp/issues/359";
-#endif
-
    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);
+}
@@ -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()));
 }
@@ -44,126 +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, EmitsSignalWithLargeMapSuccesfully)
+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));
-  m_adaptor->emitSignalWithMap(largeMap);
+  this->m_adaptor->emitSignalWithMap(largeMap);

-  ASSERT_TRUE(waitUntil(m_proxy->m_gotSignalWithMap));
-  ASSERT_THAT(m_proxy->m_mapFromSignal[0], Eq("This is string nr. 1"));
-  ASSERT_THAT(m_proxy->m_mapFromSignal[1], Eq("This is string nr. 2"));
+  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"));
 }

-TEST_F(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
+TYPED_TEST(SdbusTestObject, EmitsSignalWithVariantSuccesfully)
 {
    double d = 3.14;
-    m_adaptor->emitSignalWithVariant(sdbus::Variant{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));
 }
@@ -48,118 +48,116 @@ 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 (::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, GetsPropertyAsynchronouslyViaPropertiesInterface)
+TYPED_TEST(SdbusTestObject, GetsPropertyAsynchronouslyViaPropertiesInterface)
 {
    std::promise<std::string> promise;
    auto future = promise.get_future();

-    m_proxy->GetAsync(INTERFACE_NAME, "state", [&](const sdbus::Error* err, sdbus::Variant value)
+    this->m_proxy->GetAsync(INTERFACE_NAME, "state", [&](std::optional<sdbus::Error> err, sdbus::Variant value)
    {
-        if (err == nullptr)
+        if (!err)
           promise.set_value(value.get<std::string>());
        else
-           promise.set_exception(std::make_exception_ptr(*err));
+           promise.set_exception(std::make_exception_ptr(*std::move(err)));
    });

    ASSERT_THAT(future.get(), Eq(DEFAULT_STATE_VALUE));
 }

-TEST_F(SdbusTestObject, GetsPropertyAsynchronouslyViaPropertiesInterfaceWithFuture)
+TYPED_TEST(SdbusTestObject, GetsPropertyAsynchronouslyViaPropertiesInterfaceWithFuture)
 {
-    auto future = m_proxy->GetAsync(INTERFACE_NAME, "state", sdbus::with_future);
+    auto future = this->m_proxy->GetAsync(INTERFACE_NAME, "state", sdbus::with_future);

-    ASSERT_THAT(future.get().get<std::string>(), Eq(DEFAULT_STATE_VALUE));
+    ASSERT_THAT(future.get().template get<std::string>(), Eq(DEFAULT_STATE_VALUE));
 }

-TEST_F(SdbusTestObject, SetsPropertyViaPropertiesInterface)
+TYPED_TEST(SdbusTestObject, SetsPropertyViaPropertiesInterface)
 {
    uint32_t newActionValue = 2345;

-    m_proxy->Set(INTERFACE_NAME, "action", sdbus::Variant{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, SetsPropertyAsynchronouslyViaPropertiesInterface)
+TYPED_TEST(SdbusTestObject, SetsPropertyAsynchronouslyViaPropertiesInterface)
 {
    uint32_t newActionValue = 2346;
    std::promise<void> promise;
    auto future = promise.get_future();

-    m_proxy->SetAsync(INTERFACE_NAME, "action", sdbus::Variant{newActionValue}, [&](const sdbus::Error* err)
+    this->m_proxy->SetAsync(INTERFACE_NAME, "action", sdbus::Variant{newActionValue}, [&](std::optional<sdbus::Error> err)
    {
-        if (err == nullptr)
+        if (!err)
            promise.set_value();
        else
-            promise.set_exception(std::make_exception_ptr(*err));
+            promise.set_exception(std::make_exception_ptr(*std::move(err)));
    });

    ASSERT_NO_THROW(future.get());
-    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+    ASSERT_THAT(this->m_proxy->action(), Eq(newActionValue));
 }

-TEST_F(SdbusTestObject, SetsPropertyAsynchronouslyViaPropertiesInterfaceWithFuture)
+TYPED_TEST(SdbusTestObject, SetsPropertyAsynchronouslyViaPropertiesInterfaceWithFuture)
 {
    uint32_t newActionValue = 2347;

-    auto future = m_proxy->SetAsync(INTERFACE_NAME, "action", sdbus::Variant{newActionValue}, sdbus::with_future);
+    auto future = this->m_proxy->SetAsync(INTERFACE_NAME, "action", sdbus::Variant{newActionValue}, sdbus::with_future);

    ASSERT_NO_THROW(future.get());
-    ASSERT_THAT(m_proxy->action(), Eq(newActionValue));
+    ASSERT_THAT(this->m_proxy->action(), Eq(newActionValue));
 }

-TEST_F(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
+TYPED_TEST(SdbusTestObject, GetsAllPropertiesViaPropertiesInterface)
 {
-    const auto properties = m_proxy->GetAll(INTERFACE_NAME);
+    const auto properties = this->m_proxy->GetAll(INTERFACE_NAME);

    ASSERT_THAT(properties, SizeIs(3));
-    EXPECT_THAT(properties.at("state").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
-    EXPECT_THAT(properties.at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
-    EXPECT_THAT(properties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+    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));
 }

-TEST_F(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterface)
+TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterface)
 {
    std::promise<std::map<std::string, sdbus::Variant>> promise;
    auto future = promise.get_future();

-    m_proxy->GetAllAsync(INTERFACE_NAME, [&](const sdbus::Error* err, std::map<std::string, sdbus::Variant> value)
+    this->m_proxy->GetAllAsync(INTERFACE_NAME, [&](std::optional<sdbus::Error> err, std::map<std::string, sdbus::Variant> value)
    {
-        if (err == nullptr)
+        if (!err)
            promise.set_value(std::move(value));
        else
-            promise.set_exception(std::make_exception_ptr(*err));
+            promise.set_exception(std::make_exception_ptr(*std::move(err)));
    });
    const auto properties = future.get();

@@ -169,24 +167,24 @@ TEST_F(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterface)
    EXPECT_THAT(properties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
 }

-TEST_F(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterfaceWithFuture)
+TYPED_TEST(SdbusTestObject, GetsAllPropertiesAsynchronouslyViaPropertiesInterfaceWithFuture)
 {
-    auto future = m_proxy->GetAllAsync(INTERFACE_NAME, sdbus::with_future);
+    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").get<std::string>(), Eq(DEFAULT_STATE_VALUE));
-    EXPECT_THAT(properties.at("action").get<uint32_t>(), Eq(DEFAULT_ACTION_VALUE));
-    EXPECT_THAT(properties.at("blocking").get<bool>(), Eq(DEFAULT_BLOCKING_VALUE));
+    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));
 }

-TEST_F(SdbusTestObject, EmitsPropertyChangedSignalForSelectedProperties)
+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));
@@ -194,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));
@@ -216,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));
@@ -269,16 +267,16 @@ 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
@@ -305,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));
@@ -322,16 +320,16 @@ 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
@@ -344,7 +342,7 @@ TEST_F(SdbusTestObject, EmitsInterfacesRemovedSignalForAllObjectInterfaces)
        signalReceived = true;
    };

-    m_adaptor->emitInterfacesRemovedSignal();
+    this->m_adaptor->emitInterfacesRemovedSignal();

    ASSERT_TRUE(waitUntil(signalReceived));
 }
@@ -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)
@@ -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;
@@ -33,6 +33,7 @@
 #include <chrono>
 #include <atomic>
 #include <utility>
+#include <memory>

 namespace sdbus { namespace test {

@@ -103,9 +104,9 @@ 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;
 };

@@ -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++
@@ -28,7 +28,17 @@

 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

 }}
@@ -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,6 +33,10 @@

 #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>
@@ -46,22 +50,17 @@

 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();
    }

 private:
@@ -89,6 +88,108 @@ 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:
@@ -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++
@@ -61,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;
@@ -85,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);
@@ -99,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);
 }
@@ -117,9 +117,9 @@ 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));
                                      });
 }

@@ -136,16 +136,16 @@ std::future<MethodReply> TestProxy::doOperationClientSideAsyncOnBasicAPILevel(ui
    auto methodCall = getProxy().createMethodCall(sdbus::test::INTERFACE_NAME, "doOperation");
    methodCall << param;

-    return getProxy().callMethod(methodCall, sdbus::with_future);
+    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));
                               });
 }

@@ -163,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));
                               });
 }

@@ -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++
@@ -33,6 +33,7 @@
 #include <chrono>
 #include <atomic>
 #include <future>
+#include <memory>

 namespace sdbus { namespace test {

@@ -84,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
@@ -92,7 +93,7 @@ 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);
@@ -115,10 +116,10 @@ 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;
 };

@@ -139,7 +140,7 @@ protected:
    void onSignalWithVariant(const sdbus::Variant&) override {}

    void onSignalWithoutRegistration(const sdbus::Struct<std::string, sdbus::Struct<sdbus::Signature>>&) {}
-    void onDoOperationReply(uint32_t, const sdbus::Error*) {}
+    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 {}
@@ -22,34 +22,6 @@ protected:
    integrationtests_adaptor(sdbus::IObject& object)
        : object_(&object)
    {
-        object_->setInterfaceFlags(INTERFACE_NAME).markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
-        object_->registerMethod("noArgNoReturn").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->noArgNoReturn(); });
-        object_->registerMethod("getInt").onInterface(INTERFACE_NAME).withOutputParamNames("anInt").implementedAs([this](){ return this->getInt(); });
-        object_->registerMethod("getTuple").onInterface(INTERFACE_NAME).withOutputParamNames("arg0", "arg1").implementedAs([this](){ return this->getTuple(); });
-        object_->registerMethod("multiply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").withOutputParamNames("result").implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); });
-        object_->registerMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").implementedAs([this](const int64_t& a, const double& b){ return this->multiplyWithNoReply(a, b); }).markAsDeprecated().withNoReply();
-        object_->registerMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).withInputParamNames("arg0").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& arg0){ return this->getInts16FromStruct(arg0); });
-        object_->registerMethod("processVariant").onInterface(INTERFACE_NAME).withInputParamNames("variant").withOutputParamNames("result").implementedAs([this](const sdbus::Variant& variant){ return this->processVariant(variant); });
-        object_->registerMethod("getMapOfVariants").onInterface(INTERFACE_NAME).withInputParamNames("x", "y").withOutputParamNames("aMapOfVariants").implementedAs([this](const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y){ return this->getMapOfVariants(x, y); });
-        object_->registerMethod("getStructInStruct").onInterface(INTERFACE_NAME).withOutputParamNames("aMapOfVariants").implementedAs([this](){ return this->getStructInStruct(); });
-        object_->registerMethod("sumStructItems").onInterface(INTERFACE_NAME).withInputParamNames("arg0", "arg1").withOutputParamNames("arg0").implementedAs([this](const sdbus::Struct<uint8_t, uint16_t>& arg0, const sdbus::Struct<int32_t, int64_t>& arg1){ return this->sumStructItems(arg0, arg1); });
-        object_->registerMethod("sumArrayItems").onInterface(INTERFACE_NAME).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); });
-        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;
@@ -59,6 +31,39 @@ protected:

    ~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()
    {
@@ -22,9 +22,6 @@ protected:
    integrationtests_proxy(sdbus::IProxy& proxy)
        : proxy_(&proxy)
    {
-        proxy_->uponSignal("simpleSignal").onInterface(INTERFACE_NAME).call([this](){ this->onSimpleSignal(); });
-        proxy_->uponSignal("signalWithMap").onInterface(INTERFACE_NAME).call([this](const std::map<int32_t, std::string>& aMap){ this->onSignalWithMap(aMap); });
-        proxy_->uponSignal("signalWithVariant").onInterface(INTERFACE_NAME).call([this](const sdbus::Variant& aVariant){ this->onSignalWithVariant(aVariant); });
    }

    integrationtests_proxy(const integrationtests_proxy&) = delete;
@@ -34,6 +31,13 @@ protected:

    ~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;
@@ -176,13 +180,12 @@ public:

    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:
@@ -213,6 +216,7 @@ public:

 private:
    sdbus::IProxy* proxy_;
+    sdbus::Slot simpleSignalSlot_;
 };

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

    perftests_adaptor(const perftests_adaptor&) = delete;
@@ -34,6 +31,14 @@ protected:

    ~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)
    {
@@ -22,7 +22,6 @@ protected:
    perftests_proxy(sdbus::IProxy& proxy)
        : proxy_(&proxy)
    {
-        proxy_->uponSignal("dataSignal").onInterface(INTERFACE_NAME).call([this](const std::string& data){ this->onDataSignal(data); });
    }

    perftests_proxy(const perftests_proxy&) = delete;
@@ -32,6 +31,11 @@ protected:

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

    thermometer_adaptor(const thermometer_adaptor&) = delete;
@@ -34,6 +33,11 @@ protected:

    ~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;

@@ -33,6 +33,10 @@ protected:

    ~thermometer_proxy() = default;

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

    concatenator_adaptor(const concatenator_adaptor&) = delete;
@@ -34,6 +32,13 @@ protected:

    ~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)
    {
@@ -23,7 +23,6 @@ protected:
    concatenator_proxy(sdbus::IProxy& proxy)
        : proxy_(&proxy)
    {
-        proxy_->uponSignal("concatenatedSignal").onInterface(INTERFACE_NAME).call([this](const std::string& concatenatedString){ this->onConcatenatedSignal(concatenatedString); });
    }

    concatenator_proxy(const concatenator_proxy&) = delete;
@@ -33,14 +32,19 @@ protected:

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

    thermometer_adaptor(const thermometer_adaptor&) = delete;
@@ -34,6 +33,11 @@ protected:

    ~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;

@@ -58,8 +62,6 @@ protected:
    factory_adaptor(sdbus::IObject& object)
        : object_(&object)
    {
-        object_->registerMethod("createDelegateObject").onInterface(INTERFACE_NAME).withOutputParamNames("delegate").implementedAs([this](sdbus::Result<sdbus::ObjectPath>&& result){ this->createDelegateObject(std::move(result)); });
-        object_->registerMethod("destroyDelegateObject").onInterface(INTERFACE_NAME).withInputParamNames("delegate").implementedAs([this](sdbus::Result<>&& result, sdbus::ObjectPath delegate){ this->destroyDelegateObject(std::move(result), std::move(delegate)); }).withNoReply();
    }

    factory_adaptor(const factory_adaptor&) = delete;
@@ -69,6 +71,13 @@ protected:

    ~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;
@@ -33,6 +33,10 @@ protected:

    ~thermometer_proxy() = default;

+    void registerProxy()
+    {
+    }
+
 public:
    uint32_t getCurrentTemperature()
    {
@@ -71,6 +75,10 @@ protected:

    ~factory_proxy() = default;

+    void registerProxy()
+    {
+    }
+
 public:
    sdbus::ObjectPath createDelegateObject()
    {
@@ -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;
@@ -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)));
+}
@@ -72,14 +72,16 @@ public:
    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));
@@ -4,7 +4,7 @@

 cmake_minimum_required(VERSION 3.5)

-project(sdbus-c++-tools VERSION 1.4.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()
@@ -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,34 +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;

-    // 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;
-
    if (!signalMethods.empty())
    {
        body << "public:" << endl << signalMethods;
@@ -163,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);

@@ -217,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("
@@ -229,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 "
@@ -241,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);
@@ -272,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)
        {
@@ -282,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]);
@@ -302,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");
@@ -339,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")
        {
@@ -356,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;
@@ -364,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
@@ -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
@@ -84,17 +84,8 @@ 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;
-
-    Nodes methods = interface["method"];
-    Nodes signals = interface["signal"];
-    Nodes properties = interface["property"];
-
-    std::string registration, declaration;
-    std::tie(registration, declaration) = processSignals(signals);
-
-    body << tab << "{" << endl
-            << registration
+            << tab << tab << ": proxy_(&proxy)" << endl
+            << tab << "{" << endl
            << tab << "}" << endl << endl;

    // Rule of Five
@@ -105,6 +96,18 @@ std::string ProxyGenerator::processInterface(Node& interface) const

    body << tab << "~" << className << "() = default;" << endl << endl;

+    Nodes methods = interface["method"];
+    Nodes signals = interface["signal"];
+    Nodes properties = interface["property"];
+
+    std::string registration, declaration;
+    std::tie(registration, declaration) = processSignals(signals);
+
+    body << tab << "void registerProxy()" << endl
+         << tab << "{" << endl
+         << registration
+         << tab << "}" << endl << endl;
+
    if (!declaration.empty())
        body << declaration << endl;

@@ -248,11 +251,11 @@ std::tuple<std::string, std::string> ProxyGenerator::processMethods(const Nodes&
            }
            else // Async methods implemented through callbacks
            {
-                definitionSS << ".uponReplyInvoke([this](const sdbus::Error* error" << (outArgTypeStr.empty() ? "" : ", ") << outArgTypeStr << ")"
-                                                 "{ this->on" << nameBigFirst << "Reply(" << outArgStr << (outArgStr.empty() ? "" : ", ") << "error); })";
+                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;
+                                   << outArgTypeStr << (outArgTypeStr.empty() ? "" : ", ")  << "std::optional<sdbus::Error> error) = 0;" << endl;
            }
        }
        else if (outArgs.size() > 0)
@@ -356,11 +359,11 @@ std::tuple<std::string, std::string> ProxyGenerator::processProperties(const Nod
                }
                else // Async methods implemented through callbacks
                {
-                    propertySS << ".uponReplyInvoke([this](const sdbus::Error* error, const sdbus::Variant& value)"
-                                                   "{ this->on" << nameBigFirst << "PropertyGetReply(value.get<" << propertyType << ">(), error); })";
+                    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, const sdbus::Error* error) = 0;" << endl;
+                                       << "const " << propertyType << "& value, std::optional<sdbus::Error> error) = 0;" << endl;
                }
            }
            propertySS << ";" << endl << tab << "}" << endl << endl;
@@ -388,11 +391,11 @@ std::tuple<std::string, std::string> ProxyGenerator::processProperties(const Nod
                }
                else // Async methods implemented through callbacks
                {
-                    propertySS << ".uponReplyInvoke([this](const sdbus::Error* error)"
-                                  "{ this->on" << nameBigFirst << "PropertySetReply(error); })";
+                    propertySS << ".uponReplyInvoke([this](std::optional<sdbus::Error> error)"
+                                  "{ this->on" << nameBigFirst << "PropertySetReply(std::move(error)); })";

                    asyncDeclarationSS << tab << "virtual void on" << nameBigFirst << "PropertySetReply("
-                                       << "const sdbus::Error* error) = 0;" << endl;
+                                       << "std::optional<sdbus::Error> error) = 0;" << endl;
                }
            }
Author	SHA1	Message	Date
Stanislav Angelovič	bce1da5a2e	fix(ci): rename cmake parameters	2024-02-16 19:05:37 +01:00
Stanislav Angelovič	c8fb8caeb9	docs: add v2 migration notes to the tutorial	2024-02-16 18:59:19 +01:00
Stanislav Angelovič	fbb4a23e62	refactor: rename connection creation methods (#406 ) 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).	2024-02-16 18:57:51 +01:00
Stanislav Angelovič	341a1f3aee	chore: update ChangeLog for v2.0.0 (#405 )	2024-02-16 09:28:16 +01:00
Stanislav Angelovič	e62525ca4f	chore: reorder some API functions (#404 ) In sdbus-c++ v1, new virtual functions (e.g. overloads of existing virtual functions) were always placed at the end of the class to keep backwards ABI compatibility. Now, with v2, these functions are reordered and functions forming a logical group are together.	2024-02-16 09:27:45 +01:00
Stanislav Angelovič	e50ce7c37f	chore: rename COMPONENTs in CMake (#402 )	2024-02-10 20:30:22 +01:00
Stanislav Angelovič	2ff5a09432	refactor: remove deprecated API stuff (#403 )	2024-02-10 20:27:14 +01:00
Stanislav Angelovič	10f701df74	refactor: rename and re-organize CMake options (#401 ) This improves usability of sdbus-c++ in downstream CMake projects. CMake options now have `SDBUSCPP_` prefix so potential conflicts with downstream options/variables are minimized. Also, all configurable options and variables are placed in a single place in the root CMake file.	2024-02-10 20:20:42 +01:00
Stanislav Angelovič	94b8058dc5	refactor: use optional for passing potential call errors (#396 ) This switches from a raw pointer to std::optional type to pass prospective call errors to the client (using std::optional was not possible years back when sdbus-c++ was based on C++14). This makes the API a little clearer, safer, idiomatically more expressive, and removes potential confusion associated with raw pointers (like ownership, lifetime questions, etc.).	2024-01-10 15:43:37 +01:00
Stanislav Angelovič	cda14c9702	refactor: add nodiscard attribute for more functions	2024-01-10 15:07:30 +01:00
Stanislav Angelovič	4b6fa20491	refactor: use correct header include order	2024-01-10 15:07:30 +01:00
Stanislav Angelovič	7c402b5ba9	refactor: add Async suffix to async callMethod functions (#394 ) This makes naming consistent, so all asynchronously working functions have Async suffix	2024-01-08 09:28:19 +01:00
Stanislav Angelovic	f7afe3d1b1	refactor: add nodiscard attribute for some functions	2023-12-30 21:11:02 +01:00
Stanislav Angelovic	18aece04d5	chore: remove legacy comments	2023-12-30 21:11:02 +01:00
Stanislav Angelovic	9092bbd44c	refactor: remove deprecated dont_request_slot_t tag	2023-12-30 21:11:02 +01:00
Stanislav Angelovic	fe773958d1	refactor: rename request_slot tag to return_slot	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	bdd0bc2c27	refactor: improve Proxy signal subscription (#389 ) This makes D-Bus proxy signal registration more flexible, more dynamic, and less error-prone since no `finishRegistration()` call is needed. A proxy can register to a signal at any time during its lifetime, and can unregister freely by simply destroying the associated slot.	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	e3040c0998	refactor: improve Object vtable registration (#388 ) This improves the D-Bus object API registration/unregistration by making it more flexible, more dynamic, closer to sd-bus API design but still on high abstraction level, and -- most importantly -- less error-prone since no `finishRegistration()` call is needed anymore.	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	29bae0aaa8	fix: add missing header to ScopeGuard.h	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	8affda1678	refactor: use sd_bus_match_signal() for signal registration (#372 ) sd_bus_match_signal() is more convenient than more general sd_bus_add_match() for signal registration, and requires less code on our side. Plus, systemd of at least v238 is required for sdbus-c++ v2, and this version already ships with sd_bus_match_signal().	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	58358eefa1	refactor: make Variant constructor explicit (#370 ) This makes the library more robust and prone to user's errors when the user writes an extension for their custom type. In case they forget to implement a serialization function for that type and yet insert an object of that type into sdbus::Message, the current behavior is that, surprisingly, the library masks the error as it resolves the call to the Variant overload, because Variant provides an implicit template converting constructor, so the library tries to construct first the Variant object from the object of custom type, and then inserting into the message that Variant object. Variant constructor serializes the underlying object into its internal message object, which resolves to the same message insertion overload, creating an infinite recursion and ultimately the stack overflow. This is undesired and plain wrong. Marking this Variant converting constructor solves these problems, plus in overall it makes the code a little safer and more verbose. With explicit Variant constructor, when the user forgets to implement a serialization function for their type, the call of such function will fail with an expressive compilation error, and will produce no undesired, surprising results.	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	8c8e40dc9d	fix(tests): enable skipped test for Clang and FreeBSD (#369 ) The test now works with Clang, libc++ and -O2 optimization, since the underlying implementation has been completely re-designed and doesn't suffer from that problem anymore.	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	f38d578478	refactor: simplify async call state flag (#368 ) Since synchronous D-Bus calls are simplified in v2.0 and no more implemented in terms of an async call, the issue reported in #362 is no more relevant, and we can return to the simple boolean flag for indicating a finished call.	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	071e38c9de	refactor: let callbacks take message objects by value (#367 ) Signatures of callbacks async_reply_handler, signal_handler, message_handler and property_set_callback were modified to take input message objects by value, as opposed to non-const ref. The callee assumes ownership of the message. This API is more idiomatic, more expressive, cleaner and safer. Move semantics is used to pass messages to the callback handlers. In some cases, this also improves performance.	2023-12-30 21:11:02 +01:00
Stanislav Angelovic	21dd77ba6c	refactor: use sd-bus API to get current message	2023-12-30 21:11:02 +01:00
Marcel Hellwig	2ef0e78ad2	fix: update cmake version for library to 2.0.0 This will also install the library as `libsdbus-c++.so.2.0.0`, which represents the actual version of this library	2023-12-30 21:11:02 +01:00
Marcel Hellwig	ab2032592b	fix: prevent installing a time event, when there's no need for a timeout See #324 for discussion	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	a7ae2ef79f	chore: require cmake v3.14 and use FetchContent_MakeAvailable	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	e87a252493	test: support new googletest git tags	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	37a7b311d6	ci: build googletest manually on older ubuntus	2023-12-30 21:11:02 +01:00
Stanislav Angelovič	e95024192c	feat: introduce sd-event integration	2023-12-30 21:11:02 +01:00
Stanislav Angelovic	8d24b2826e	chore: enable actions on release/v2.0 branch	2023-12-30 21:11:02 +01:00
Stanislav Angelovic	0f99724449	refactor: simplify async D-Bus connection handling	2023-12-30 21:10:51 +01:00