Bump revision up to 0.8.0

CMakeLists.txt

@@ -4,7 +4,7 @@
 
 cmake_minimum_required(VERSION 3.6)
 
-project(sdbus-c++ VERSION 0.7.8 LANGUAGES C CXX)
+project(sdbus-c++ VERSION 0.8.0 LANGUAGES C CXX)
 
 include(GNUInstallDirs) # Installation directories for `install` command and pkgconfig file
 

ChangeLog

@@ -138,3 +138,7 @@ v0.7.7
 
 v0.7.8
 - Switch from thread_local to global bus instance that is used to create Variant instances (thread_local caused issues with Variant in very special inter-thread situations)
+
+v0.8.0
+- [[Breaking ABI change]]  Implement support for input & output parameter names for D-Bus methods and signals, which are used in introspection
+- Explain better in tutorial the design and how to use connections in relation to objects and proxies

docs/using-sdbus-c++.md

@@ -353,27 +353,33 @@ The design of D-Bus connections in sdbus-c++ allows for certain flexibility and
 
 How shall we use connections in relation to D-Bus objects and object proxies?
 
-A D-Bus connection is represented by a `IConnection` instance. Each connection needs an event loop being run upon it. So it needs a thread handling the event loop. This thread serves all incoming and outgoing messages and all communication towards D-Bus daemon.
+A D-Bus connection is represented by a `IConnection` instance. Each connection needs an event loop being run upon it. So it needs a thread handling the event loop. This thread serves all incoming and outgoing messages and all communication towards D-Bus daemon. One process can have one but also multiple D-Bus connections (we just have to make certain that the connections with assigned bus names don't share a common name; the name must be unique).
 
-One process can have multiple D-Bus connections, with assigned unique bus names or without, as long as those with assigned bus names do not share a common bus name.
+A typical use case for most services is **one** D-Bus connection in the application. The application runs event loop on that connection. When creating objects or proxies, the application provides reference of that connection to those objects and proxies. This means all these objects and proxies share the same connection. This is nicely scalable, because with whatever number of objects or proxies, there is only one connection and one event loop thread. Yet, services that provide objects at various bus names have to create and maintain multiple D-Bus connections, each with the unique bus name.
 
-A D-Bus connection can be created for and used exclusively by one D-Bus object (represented by one `IObject` instance) or one D-Bus proxy (represented by one `IProxy` instance), but can very well be used by and shared across multiple objects, multiple proxies or even both multiple objects and proxies at the same time. When shared, one must bear in mind that the access to the connection is mutually exclusive and is serialized. This means, for example, that if an object's callback is going to be invoked for an incoming remote method call and in another thread we use a proxy to call remote method in another process, the threads are contending and only one can go on while the other must wait and can only proceed after the first one has finished, because both are using a shared resource -- the connection.
+The connection is thread-safe and objects and proxies can invoke operations on it from multiple threads simultaneously, but the operations are serialized. This means, for example, that if an object's callback for an incoming remote method call is going to be invoked in an event loop thread, and in another thread we use a proxy to call remote method in another process, the threads are contending and only one can go on while the other must wait and can only proceed after the first one has finished, because both are using a shared resource -- the connection.
 
-The former case (1:1) is one extreme; it's usually simple, has zero resource contention, but hurts scalability (for example, 50 proxies in our program need 50 D-Bus connections and 50 event loop threads upon them). The latter case (1:N) is the other extreme -- all D-Bus objects and proxies share one single connection. This is the most scalable solution (since, for example, 5 or 200 objects/proxies use always one single connection), but may increase contention and hurt concurrency (since only one of all those objects/proxies can work with the connection at a time). And then there are limitless options between the two (for example, we can use one connection for all objects, and another connection for all proxies in our service...). sdbus-c++ gives its users freedom to choose whatever approach is more suitable to them in their application at fine granularity.
+We should bear that in mind when designing more complex, multi-threaded services with high parallelism. If we have undesired contention on a connection, creating a specific, dedicated connection for a hot spot helps to increase concurrency. sdbus-c++ provides us freedom to create as many connections as we want and assign objects and proxies to those connections at our will. We, as application developers, choose whatever approach is more suitable to us at quite a fine granularity.
 
-How can we use connections from the server and the client perspective?
+So, more technically, how can we use connections from the server and the client perspective?
 
-* On the *server* side, we generally need to create D-Bus objects and publish their APIs. For that we first need a connection with a unique bus name. We need to create the D-Bus connection manually ourselves, request bus name on it, and manually launch its event loop (in a blocking way, through `enterProcessingLoop()`, or non-blocking async way, through `enterProcessingLoopAsync()`). At any time before or after running the event loop on the connection, we can create and "hook", as well as remove, objects and proxies upon that connection.
+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 *client* side, for our D-Bus object proxies, we have more options (corresponding to three overloads of the `createProxy()` factory):
+  * either in a blocking way, through `enterProcessingLoop()`,  
+  * or in a non-blocking async way, through `enterProcessingLoopAsync()`),
+  * 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 and use that fd in our loop.
 
-    * We don't bother about any connection when creating a proxy. For each proxy instance sdbus-c++ also creates an internal connection instance to be used just by this proxy, and it will be a *system bus* connection. Additionally, an event loop thread for that connection is created and run internally.
+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.
 
-      This hurts scalability (see discussion above), but our code is simpler, and since each proxy has its own connection, there is zero contention.
+On the **client** side we have more options when creating D-Bus proxies. That corresponds to three overloads of the `createProxy()` factory:
 
-    * We create a connection explicitly by ourselves and `std::move` it to the proxy object factory. The proxy becomes an owner of this connection, and will run the event loop on that connection. This is the same as in the above bullet point, but with a flexibility that we can choose the bus type (system, session bus).
+  * In case we (the application) already maintain a D-Bus connection, e.g. because we a D-Bus service anyway, the simple and typical approach is to create proxy upon that connection. The proxy will share the connection with others. So we pass connection reference to proxy factory. With this approach we must of course ensure that the connection exists as long as the proxy exists.
+  
+  * Or -- and this is typical when we have a simple D-Bus client application -- we have another option: we let proxy maintain its own connection (and an associated thread):
+  
+    * We either create the connection ourselves and `std::move` it to the proxy object factory. The proxy becomes an owner of this connection, and will run the event loop on that connection. This had the advantage that we may choose the type of connection (system, session, remote).
 
-    * We are always full owners of the connection. We create the connection, and a proxy only takes and keeps a reference to it. We take care of the event loop upon that connection (and we must ensure the connection exists as long as all its users exist).
+    * Or we don't bother about any connection at all when creating a proxy (the factory overload with no connection parameter). Under the hood, the proxy creates its own *system bus* connection, creates a separate thread and runs an event loop in it. This is **the simplest approach** for non-complex D-Bus clients. For more complex ones, with big number of proxies, this hurts scalability but may improve concurrency (see discussion higher above), so we should make a conscious choice.
 
 Implementing the Concatenator example using convenience sdbus-c++ API layer
 ---------------------------------------------------------------------------
@@ -385,11 +391,11 @@ The convenience API layer abstracts the concept of underlying D-Bus messages awa
 Thus, in the end of the day, the code written using the convenience API is:
 
   - more expressive,
-  - closer to the abstraction level of the problem being solved,
-  - shorter,
+  - at a higher level of abstraction (closer to the abstraction level of the problem being solved),
+  - significantly shorter,
   - almost as fast as one written using the basic API layer.
 
-The code written using this layer expresses *what* it does, rather then *how*. Let's look at code samples.
+The code written using this layer expresses in a declarative way *what* it does, rather then *how*. Let's look at code samples.
 
 ### Server side
 
@@ -505,10 +511,17 @@ When registering methods, calling methods or emitting signals, multiple lines of
 
 sdbus-c++ users shall prefer the convenience API to the lower level, basic API. When feasible, using generated adaptor and proxy stubs is even better. These stubs provide yet another, higher API level built on top of the convenience API. They are described in the following section.
 
+Tip: When registering a D-Bus object, we can additionally provide names of input and output parameters of its methods and names of parameters of its signals. When the object is introspected, these names are listed in the resulting introspection XML, which improves the description of object's interfaces:
+
+```c++
+    concatenator->registerMethod("concatenate").onInterface(interfaceName).withInputParamNames("numbers", "separator").withOutputParamNames("concatenatedString").implementedAs(&concatenate);
+    concatenator->registerSignal("concatenated").onInterface(interfaceName).withParameters<std::string>("concatenatedString");
+```
+
 Implementing the Concatenator example using sdbus-c++-generated stubs
 ---------------------------------------------------------------------
 
-sdbus-c++ ships with the native stub generator tool called `sdbus-c++-xml2cpp`. The tool is very similar to `dbusxx-xml2cpp` tool that comes with the dbus-c++ project.
+sdbus-c++ ships with the native stub generator tool called `sdbus-c++-xml2cpp`. The tool is very similar to `dbusxx-xml2cpp` tool that comes with the dbus-c++ library.
 
 The generator tool takes D-Bus XML IDL description of D-Bus interfaces on its input, and can be instructed to generate one or both of these: an adaptor header file for use on the server side, and a proxy header file for use on the client side. Like this:
 
@@ -569,8 +582,8 @@ protected:
     Concatenator_adaptor(sdbus::IObject& object)
         : object_(object)
     {
-        object_.registerMethod("concatenate").onInterface(INTERFACE_NAME).implementedAs([this](const std::vector<int32_t>& numbers, const std::string& separator){ return this->concatenate(numbers, separator); });
-        object_.registerSignal("concatenated").onInterface(INTERFACE_NAME).withParameters<std::string>();
+        object_.registerMethod("concatenate").onInterface(INTERFACE_NAME).withInputParamNames("numbers", "separator").withOutputParamNames("concatenatedString").implementedAs([this](const std::vector<int32_t>& numbers, const std::string& separator){ return this->concatenate(numbers, separator); });
+        object_.registerSignal("concatenated").onInterface(INTERFACE_NAME).withParameters<std::string>("concatenatedString");
     }
 
     ~Concatenator_adaptor() = default;
@@ -1050,7 +1063,7 @@ Using D-Bus properties
 
 Defining and working with D-Bus properties using XML description is quite easy.
 
-### Defining a property in the XML
+### Defining a property in the IDL
 
 A property element has no arg child element. It just has the attributes name, type and access, which are all mandatory. The access attribute allows the values ‘readwrite’, ‘read’, and ‘write’.
 

include/sdbus-c++/ConvenienceApiClasses.h

@@ -31,6 +31,7 @@
 #include <sdbus-c++/TypeTraits.h>
 #include <sdbus-c++/Flags.h>
 #include <string>
+#include <vector>
 #include <type_traits>
 #include <chrono>
 #include <cstdint>
@@ -45,6 +46,9 @@ namespace sdbus {
 
 namespace sdbus {
 
+    template <typename... _Args>
+    inline constexpr bool are_strings_v = std::conjunction<std::is_convertible<_Args, std::string>...>::value;
+
     class MethodRegistrator
     {
     public:
@@ -57,6 +61,12 @@ namespace sdbus {
         std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
         template <typename _Function>
         std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&> implementedAs(_Function&& callback);
+        MethodRegistrator& withInputParamNames(std::vector<std::string> paramNames);
+        template <typename... _String>
+        std::enable_if_t<are_strings_v<_String...>, MethodRegistrator&> withInputParamNames(_String... paramNames);
+        MethodRegistrator& withOutputParamNames(std::vector<std::string> paramNames);
+        template <typename... _String>
+        std::enable_if_t<are_strings_v<_String...>, MethodRegistrator&> withOutputParamNames(_String... paramNames);
         MethodRegistrator& markAsDeprecated();
         MethodRegistrator& markAsPrivileged();
         MethodRegistrator& withNoReply();
@@ -66,7 +76,9 @@ namespace sdbus {
         const std::string& methodName_;
         std::string interfaceName_;
         std::string inputSignature_;
+        std::vector<std::string> inputParamNames_;
         std::string outputSignature_;
+        std::vector<std::string> outputParamNames_;
         method_callback methodCallback_;
         Flags flags_;
         int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
@@ -81,6 +93,9 @@ namespace sdbus {
 
         SignalRegistrator& onInterface(std::string interfaceName);
         template <typename... _Args> SignalRegistrator& withParameters();
+        template <typename... _Args> SignalRegistrator& withParameters(std::vector<std::string> paramNames);
+        template <typename... _Args, typename... _String>
+        std::enable_if_t<are_strings_v<_String...>, SignalRegistrator&> withParameters(_String... paramNames);
         SignalRegistrator& markAsDeprecated();
 
     private:
@@ -88,6 +103,7 @@ namespace sdbus {
         const std::string& signalName_;
         std::string interfaceName_;
         std::string signalSignature_;
+        std::vector<std::string> paramNames_;
         Flags flags_;
         int exceptions_{}; // Number of active exceptions when SignalRegistrator is constructed
     };

include/sdbus-c++/ConvenienceApiClasses.inl

@@ -70,7 +70,14 @@ namespace sdbus {
         // Therefore, we can allow registerMethod() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerMethod(interfaceName_, methodName_, inputSignature_, outputSignature_, std::move(methodCallback_), flags_);
+        object_.registerMethod( interfaceName_
+                              , std::move(methodName_)
+                              , std::move(inputSignature_)
+                              , std::move(inputParamNames_)
+                              , std::move(outputSignature_)
+                              , std::move(outputParamNames_)
+                              , std::move(methodCallback_)
+                              , std::move(flags_));
     }
 
     inline MethodRegistrator& MethodRegistrator::onInterface(std::string interfaceName)
@@ -81,7 +88,8 @@ namespace sdbus {
     }
 
     template <typename _Function>
-    inline std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&> MethodRegistrator::implementedAs(_Function&& callback)
+    inline std::enable_if_t<!is_async_method_v<_Function>, MethodRegistrator&>
+    MethodRegistrator::implementedAs(_Function&& callback)
     {
         inputSignature_ = signature_of_function_input_arguments<_Function>::str();
         outputSignature_ = signature_of_function_output_arguments<_Function>::str();
@@ -110,7 +118,8 @@ namespace sdbus {
     }
 
     template <typename _Function>
-    inline std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&> MethodRegistrator::implementedAs(_Function&& callback)
+    inline std::enable_if_t<is_async_method_v<_Function>, MethodRegistrator&>
+    MethodRegistrator::implementedAs(_Function&& callback)
     {
         inputSignature_ = signature_of_function_input_arguments<_Function>::str();
         outputSignature_ = signature_of_function_output_arguments<_Function>::str();
@@ -130,6 +139,32 @@ namespace sdbus {
         return *this;
     }
 
+    inline MethodRegistrator& MethodRegistrator::withInputParamNames(std::vector<std::string> paramNames)
+    {
+        inputParamNames_ = std::move(paramNames);
+
+        return *this;
+    }
+
+    template <typename... _String>
+    inline std::enable_if_t<are_strings_v<_String...>, MethodRegistrator&> MethodRegistrator::withInputParamNames(_String... paramNames)
+    {
+        return withInputParamNames({paramNames...});
+    }
+
+    inline MethodRegistrator& MethodRegistrator::withOutputParamNames(std::vector<std::string> paramNames)
+    {
+        outputParamNames_ = std::move(paramNames);
+
+        return *this;
+    }
+
+    template <typename... _String>
+    inline std::enable_if_t<are_strings_v<_String...>, MethodRegistrator&> MethodRegistrator::withOutputParamNames(_String... paramNames)
+    {
+        return withOutputParamNames({paramNames...});
+    }
+
     inline MethodRegistrator& MethodRegistrator::markAsDeprecated()
     {
         flags_.set(Flags::DEPRECATED);
@@ -179,7 +214,11 @@ namespace sdbus {
         // Therefore, we can allow registerSignal() to throw even if we are in the destructor.
         // Bottomline is, to be on the safe side, the caller must take care of catching and reacting
         // to the exception thrown from here if the caller is a destructor itself.
-        object_.registerSignal(interfaceName_, signalName_, signalSignature_, flags_);
+        object_.registerSignal( interfaceName_
+                              , std::move(signalName_)
+                              , std::move(signalSignature_)
+                              , std::move(paramNames_)
+                              , std::move(flags_) );
     }
 
     inline SignalRegistrator& SignalRegistrator::onInterface(std::string interfaceName)
@@ -197,6 +236,23 @@ namespace sdbus {
         return *this;
     }
 
+    template <typename... _Args>
+    inline SignalRegistrator& SignalRegistrator::withParameters(std::vector<std::string> paramNames)
+    {
+        paramNames_ = std::move(paramNames);
+
+        return withParameters<_Args...>();
+    }
+
+    template <typename... _Args, typename... _String>
+    inline std::enable_if_t<are_strings_v<_String...>, SignalRegistrator&>
+    SignalRegistrator::withParameters(_String... paramNames)
+    {
+        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);

include/sdbus-c++/IObject.h

@@ -74,9 +74,37 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual void registerMethod( const std::string& interfaceName
-                                   , const std::string& methodName
-                                   , const std::string& inputSignature
-                                   , const std::string& outputSignature
+                                   , std::string methodName
+                                   , std::string inputSignature
+                                   , std::string outputSignature
+                                   , method_callback methodCallback
+                                   , Flags flags = {} ) = 0;
+
+        /*!
+         * @brief Registers method that the object will provide on D-Bus
+         *
+         * @param[in] interfaceName Name of an interface that the method will belong to
+         * @param[in] methodName Name of the method
+         * @param[in] inputSignature D-Bus signature of method input parameters
+         * @param[in] inputNames Names of input parameters
+         * @param[in] outputSignature D-Bus signature of method output parameters
+         * @param[in] outputNames Names of output parameters
+         * @param[in] methodCallback Callback that implements the body of the method
+         * @param[in] flags D-Bus method flags (privileged, deprecated, or no reply)
+         *
+         * Provided names of input and output parameters will be included in the introspection
+         * description (given that at least version 242 of underlying libsystemd library is
+         * used; otherwise, names of parameters are ignored). This usually helps better describe
+         * the API to the introspector.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void registerMethod( const std::string& interfaceName
+                                   , std::string methodName
+                                   , std::string inputSignature
+                                   , const std::vector<std::string>& inputNames
+                                   , std::string outputSignature
+                                   , const std::vector<std::string>& outputNames
                                    , method_callback methodCallback
                                    , Flags flags = {} ) = 0;
 
@@ -91,8 +119,30 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual void registerSignal( const std::string& interfaceName
-                                   , const std::string& signalName
-                                   , const std::string& signature
+                                   , std::string signalName
+                                   , std::string signature
+                                   , Flags flags = {} ) = 0;
+
+        /*!
+         * @brief Registers signal that the object will emit on D-Bus
+         *
+         * @param[in] interfaceName Name of an interface that the signal will fall under
+         * @param[in] signalName Name of the signal
+         * @param[in] signature D-Bus signature of signal parameters
+         * @param[in] paramNames Names of parameters of the signal
+         * @param[in] flags D-Bus signal flags (deprecated)
+         *
+         * Provided names of signal output parameters will be included in the introspection
+         * description (given that at least version 242 of underlying libsystemd library is
+         * used; otherwise, names of parameters are ignored). This usually helps better describe
+         * the API to the introspector.
+         *
+         * @throws sdbus::Error in case of failure
+         */
+        virtual void registerSignal( const std::string& interfaceName
+                                   , std::string signalName
+                                   , std::string signature
+                                   , const std::vector<std::string>& paramNames
                                    , Flags flags = {} ) = 0;
 
         /*!
@@ -107,8 +157,8 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual void registerProperty( const std::string& interfaceName
-                                     , const std::string& propertyName
-                                     , const std::string& signature
+                                     , std::string propertyName
+                                     , std::string signature
                                      , property_get_callback getCallback
                                      , Flags flags = {} ) = 0;
 
@@ -125,8 +175,8 @@ namespace sdbus {
          * @throws sdbus::Error in case of failure
          */
         virtual void registerProperty( const std::string& interfaceName
-                                     , const std::string& propertyName
-                                     , const std::string& signature
+                                     , std::string propertyName
+                                     , std::string signature
                                      , property_get_callback getCallback
                                      , property_set_callback setCallback
                                      , Flags flags = {} ) = 0;

src/Object.cpp

@@ -45,51 +45,83 @@ Object::Object(sdbus::internal::IConnection& connection, std::string objectPath)
 }
 
 void Object::registerMethod( const std::string& interfaceName
-                           , const std::string& methodName
-                           , const std::string& inputSignature
-                           , const std::string& outputSignature
+                           , std::string methodName
+                           , std::string inputSignature
+                           , std::string outputSignature
+                           , method_callback methodCallback
+                           , Flags flags )
+{
+    registerMethod( interfaceName
+                  , std::move(methodName)
+                  , std::move(inputSignature)
+                  , {}
+                  , std::move(outputSignature)
+                  , {}
+                  , std::move(methodCallback)
+                  , std::move(flags) );
+}
+
+void Object::registerMethod( const std::string& interfaceName
+                           , std::string methodName
+                           , std::string inputSignature
+                           , const std::vector<std::string>& inputNames
+                           , std::string outputSignature
+                           , const std::vector<std::string>& outputNames
                            , method_callback methodCallback
                            , Flags flags )
 {
     SDBUS_THROW_ERROR_IF(!methodCallback, "Invalid method callback provided", EINVAL);
 
     auto& interface = interfaces_[interfaceName];
-    InterfaceData::MethodData methodData{inputSignature, outputSignature, std::move(methodCallback), flags};
-    auto inserted = interface.methods_.emplace(methodName, std::move(methodData)).second;
+    InterfaceData::MethodData methodData{ std::move(inputSignature)
+                                        , std::move(outputSignature)
+                                        , paramNamesToString(inputNames) + paramNamesToString(outputNames)
+                                        , std::move(methodCallback)
+                                        , std::move(flags) };
+    auto inserted = interface.methods.emplace(std::move(methodName), std::move(methodData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register method: method already exists", EINVAL);
 }
 
 void Object::registerSignal( const std::string& interfaceName
-                           , const std::string& signalName
-                           , const std::string& signature
+                           , std::string signalName
+                           , std::string signature
+                           , Flags flags )
+{
+    registerSignal(interfaceName, std::move(signalName), std::move(signature), {}, std::move(flags));
+}
+
+void Object::registerSignal( const std::string& interfaceName
+                           , std::string signalName
+                           , std::string signature
+                           , const std::vector<std::string>& paramNames
                            , Flags flags )
 {
     auto& interface = interfaces_[interfaceName];
 
-    InterfaceData::SignalData signalData{signature, flags};
-    auto inserted = interface.signals_.emplace(signalName, std::move(signalData)).second;
+    InterfaceData::SignalData signalData{std::move(signature), paramNamesToString(paramNames), std::move(flags)};
+    auto inserted = interface.signals.emplace(std::move(signalName), std::move(signalData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register signal: signal already exists", EINVAL);
 }
 
 void Object::registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
+                             , std::string propertyName
+                             , std::string signature
                              , property_get_callback getCallback
                              , Flags flags )
 {
     registerProperty( interfaceName
-                    , propertyName
-                    , signature
-                    , getCallback
-                    , property_set_callback{}
-                    , flags );
+                    , std::move(propertyName)
+                    , std::move(signature)
+                    , std::move(getCallback)
+                    , {}
+                    , std::move(flags) );
 }
 
 void Object::registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
+                             , std::string propertyName
+                             , std::string signature
                              , property_get_callback getCallback
                              , property_set_callback setCallback
                              , Flags flags )
@@ -98,8 +130,11 @@ void Object::registerProperty( const std::string& interfaceName
 
     auto& interface = interfaces_[interfaceName];
 
-    InterfaceData::PropertyData propertyData{signature, std::move(getCallback), std::move(setCallback), flags};
-    auto inserted = interface.properties_.emplace(propertyName, std::move(propertyData)).second;
+    InterfaceData::PropertyData propertyData{ std::move(signature)
+                                            , std::move(getCallback)
+                                            , std::move(setCallback)
+                                            , std::move(flags)};
+    auto inserted = interface.properties.emplace(std::move(propertyName), std::move(propertyData)).second;
 
     SDBUS_THROW_ERROR_IF(!inserted, "Failed to register property: property already exists", EINVAL);
 }
@@ -107,7 +142,7 @@ void Object::registerProperty( const std::string& interfaceName
 void Object::setInterfaceFlags(const std::string& interfaceName, Flags flags)
 {
     auto& interface = interfaces_[interfaceName];
-    interface.flags_ = flags;
+    interface.flags = flags;
 }
 
 void Object::finishRegistration()
@@ -192,10 +227,10 @@ sdbus::IConnection& Object::getConnection() const
 
 const std::vector<sd_bus_vtable>& Object::createInterfaceVTable(InterfaceData& interfaceData)
 {
-    auto& vtable = interfaceData.vtable_;
+    auto& vtable = interfaceData.vtable;
     assert(vtable.empty());
 
-    vtable.push_back(createVTableStartItem(interfaceData.flags_.toSdBusInterfaceFlags()));
+    vtable.push_back(createVTableStartItem(interfaceData.flags.toSdBusInterfaceFlags()));
     registerMethodsToVTable(interfaceData, vtable);
     registerSignalsToVTable(interfaceData, vtable);
     registerPropertiesToVTable(interfaceData, vtable);
@@ -206,14 +241,15 @@ const std::vector<sd_bus_vtable>& Object::createInterfaceVTable(InterfaceData& i
 
 void Object::registerMethodsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
 {
-    for (const auto& item : interfaceData.methods_)
+    for (const auto& item : interfaceData.methods)
     {
         const auto& methodName = item.first;
         const auto& methodData = item.second;
 
         vtable.push_back(createVTableMethodItem( methodName.c_str()
-                                               , methodData.inputArgs_.c_str()
-                                               , methodData.outputArgs_.c_str()
+                                               , methodData.inputArgs.c_str()
+                                               , methodData.outputArgs.c_str()
+                                               , methodData.paramNames.c_str()
                                                , &Object::sdbus_method_callback
                                                , methodData.flags_.toSdBusMethodFlags() ));
     }
@@ -221,35 +257,36 @@ void Object::registerMethodsToVTable(const InterfaceData& interfaceData, std::ve
 
 void Object::registerSignalsToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
 {
-    for (const auto& item : interfaceData.signals_)
+    for (const auto& item : interfaceData.signals)
     {
         const auto& signalName = item.first;
         const auto& signalData = item.second;
 
         vtable.push_back(createVTableSignalItem( signalName.c_str()
-                                               , signalData.signature_.c_str()
-                                               , signalData.flags_.toSdBusSignalFlags() ));
+                                               , signalData.signature.c_str()
+                                               , signalData.paramNames.c_str()
+                                               , signalData.flags.toSdBusSignalFlags() ));
     }
 }
 
 void Object::registerPropertiesToVTable(const InterfaceData& interfaceData, std::vector<sd_bus_vtable>& vtable)
 {
-    for (const auto& item : interfaceData.properties_)
+    for (const auto& item : interfaceData.properties)
     {
         const auto& propertyName = item.first;
         const auto& propertyData = item.second;
 
-        if (!propertyData.setCallback_)
+        if (!propertyData.setCallback)
             vtable.push_back(createVTablePropertyItem( propertyName.c_str()
-                                                     , propertyData.signature_.c_str()
+                                                     , propertyData.signature.c_str()
                                                      , &Object::sdbus_property_get_callback
-                                                     , propertyData.flags_.toSdBusPropertyFlags() ));
+                                                     , propertyData.flags.toSdBusPropertyFlags() ));
         else
             vtable.push_back(createVTableWritablePropertyItem( propertyName.c_str()
-                                                             , propertyData.signature_.c_str()
+                                                             , propertyData.signature.c_str()
                                                              , &Object::sdbus_property_get_callback
                                                              , &Object::sdbus_property_set_callback
-                                                             , propertyData.flags_.toSdBusWritablePropertyFlags() ));
+                                                             , propertyData.flags.toSdBusWritablePropertyFlags() ));
     }
 }
 
@@ -257,7 +294,15 @@ void Object::activateInterfaceVTable( const std::string& interfaceName
                                     , InterfaceData& interfaceData
                                     , const std::vector<sd_bus_vtable>& vtable )
 {
-    interfaceData.slot_ = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
+    interfaceData.slot = connection_.addObjectVTable(objectPath_, interfaceName, &vtable[0], this);
+}
+
+std::string Object::paramNamesToString(const std::vector<std::string>& paramNames)
+{
+    std::string names;
+    for (const auto& name : paramNames)
+        names += name + '\0';
+    return names;
 }
 
 int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError)
@@ -268,7 +313,7 @@ int Object::sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData,
     auto message = Message::Factory::create<MethodCall>(sdbusMessage, &object->connection_.getSdBusInterface());
 
     // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[message.getInterfaceName()].methods_[message.getMemberName()].callback_;
+    auto& callback = object->interfaces_[message.getInterfaceName()].methods[message.getMemberName()].callback;
     assert(callback);
 
     try
@@ -295,7 +340,7 @@ int Object::sdbus_property_get_callback( sd_bus */*bus*/
     assert(object != nullptr);
 
     // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[interface].properties_[property].getCallback_;
+    auto& callback = object->interfaces_[interface].properties[property].getCallback;
     // Getter can be empty - the case of "write-only" property
     if (!callback)
     {
@@ -329,7 +374,7 @@ int Object::sdbus_property_set_callback( sd_bus */*bus*/
     assert(object != nullptr);
 
     // Note: The lookup can be optimized by using sorted vectors instead of associative containers
-    auto& callback = object->interfaces_[interface].properties_[property].setCallback_;
+    auto& callback = object->interfaces_[interface].properties[property].setCallback;
     assert(callback);
 
     auto value = Message::Factory::create<PropertySetCall>(sdbusValue, &object->connection_.getSdBusInterface());

src/Object.h

@@ -47,26 +47,38 @@ namespace internal {
         Object(sdbus::internal::IConnection& connection, std::string objectPath);
 
         void registerMethod( const std::string& interfaceName
-                           , const std::string& methodName
-                           , const std::string& inputSignature
-                           , const std::string& outputSignature
+                           , std::string methodName
+                           , std::string inputSignature
+                           , std::string outputSignature
+                           , method_callback methodCallback
+                           , Flags flags ) override;
+        void registerMethod( const std::string& interfaceName
+                           , std::string methodName
+                           , std::string inputSignature
+                           , const std::vector<std::string>& inputNames
+                           , std::string outputSignature
+                           , const std::vector<std::string>& outputNames
                            , method_callback methodCallback
                            , Flags flags ) override;
 
         void registerSignal( const std::string& interfaceName
-                           , const std::string& signalName
-                           , const std::string& signature
+                           , std::string signalName
+                           , std::string signature
+                           , Flags flags ) override;
+        void registerSignal( const std::string& interfaceName
+                           , std::string signalName
+                           , std::string signature
+                           , const std::vector<std::string>& paramNames
                            , Flags flags ) override;
 
         void registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
+                             , std::string propertyName
+                             , std::string signature
                              , property_get_callback getCallback
                              , Flags flags ) override;
-
         void registerProperty( const std::string& interfaceName
-                             , const std::string& propertyName
-                             , const std::string& signature
+                             , std::string propertyName
+                             , std::string signature
                              , property_get_callback getCallback
                              , property_set_callback setCallback
                              , Flags flags ) override;
@@ -98,32 +110,34 @@ namespace internal {
             using MethodName = std::string;
             struct MethodData
             {
-                std::string inputArgs_;
-                std::string outputArgs_;
-                method_callback callback_;
+                const std::string inputArgs;
+                const std::string outputArgs;
+                const std::string paramNames;
+                method_callback callback;
                 Flags flags_;
             };
-            std::map<MethodName, MethodData> methods_;
+            std::map<MethodName, MethodData> methods;
             using SignalName = std::string;
             struct SignalData
             {
-                std::string signature_;
-                Flags flags_;
+                const std::string signature;
+                const std::string paramNames;
+                Flags flags;
             };
-            std::map<SignalName, SignalData> signals_;
+            std::map<SignalName, SignalData> signals;
             using PropertyName = std::string;
             struct PropertyData
             {
-                std::string signature_;
-                property_get_callback getCallback_;
-                property_set_callback setCallback_;
-                Flags flags_;
+                const std::string signature;
+                property_get_callback getCallback;
+                property_set_callback setCallback;
+                Flags flags;
             };
-            std::map<PropertyName, PropertyData> properties_;
-            std::vector<sd_bus_vtable> vtable_;
-            Flags flags_;
+            std::map<PropertyName, PropertyData> properties;
+            std::vector<sd_bus_vtable> vtable;
+            Flags flags;
 
-            SlotPtr slot_;
+            SlotPtr slot;
         };
 
         static const std::vector<sd_bus_vtable>& createInterfaceVTable(InterfaceData& interfaceData);
@@ -133,6 +147,7 @@ namespace internal {
         void activateInterfaceVTable( const std::string& interfaceName
                                     , InterfaceData& interfaceData
                                     , const std::vector<sd_bus_vtable>& vtable );
+        static std::string paramNamesToString(const std::vector<std::string>& paramNames);
 
         static int sdbus_method_callback(sd_bus_message *sdbusMessage, void *userData, sd_bus_error *retError);
         static int sdbus_property_get_callback( sd_bus *bus

src/VTableUtils.c

@@ -36,18 +36,46 @@ sd_bus_vtable createVTableStartItem(uint64_t flags)
 sd_bus_vtable createVTableMethodItem( const char *member
                                     , const char *signature
                                     , const char *result
+                                    , const char *paramNames
                                     , sd_bus_message_handler_t handler
                                     , uint64_t flags )
 {
+#if LIBSYSTEMD_VERSION>=242
+    // We have to expand macro SD_BUS_METHOD_WITH_NAMES manually here, because the macro expects literal char strings
+    /*struct sd_bus_vtable vtableItem = SD_BUS_METHOD_WITH_NAMES(member, signature, innames, result, outnames, handler, flags);*/
+    struct sd_bus_vtable vtableItem =
+    {
+            .type = _SD_BUS_VTABLE_METHOD,
+            .flags = flags,
+            .x = {
+                .method = {
+                    .member = member,
+                    .signature = signature,
+                    .result = result,
+                    .handler = handler,
+                    .offset = 0,
+                    .names = paramNames,
+                },
+            },
+    };
+#else
+    (void)paramNames;
     struct sd_bus_vtable vtableItem = SD_BUS_METHOD(member, signature, result, handler, flags);
+#endif
     return vtableItem;
 }
 
 sd_bus_vtable createVTableSignalItem( const char *member
                                     , const char *signature
+                                    , const char *outnames
                                     , uint64_t flags )
 {
+#if LIBSYSTEMD_VERSION>=242
+    struct sd_bus_vtable vtableItem = SD_BUS_SIGNAL_WITH_NAMES(member, signature, outnames, flags);
+#else
+    (void)outnames;
     struct sd_bus_vtable vtableItem = SD_BUS_SIGNAL(member, signature, flags);
+#endif
     return vtableItem;
 }
 

src/VTableUtils.h

@@ -38,10 +38,12 @@ sd_bus_vtable createVTableStartItem(uint64_t flags);
 sd_bus_vtable createVTableMethodItem( const char *member
                                     , const char *signature
                                     , const char *result
+                                    , const char *paramNames
                                     , sd_bus_message_handler_t handler
                                     , uint64_t flags );
 sd_bus_vtable createVTableSignalItem( const char *member
                                     , const char *signature
+                                    , const char *outnames
                                     , uint64_t flags );
 sd_bus_vtable createVTablePropertyItem( const char *member
                                       , const char *signature

tests/integrationtests/adaptor-glue.h

@@ -60,17 +60,18 @@ protected:
         object_.setInterfaceFlags(INTERFACE_NAME).markAsDeprecated().withPropertyUpdateBehavior(sdbus::Flags::EMITS_NO_SIGNAL);
 
         object_.registerMethod("noArgNoReturn").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->noArgNoReturn(); });
-        object_.registerMethod("getInt").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getInt(); });
+        object_.registerMethod("getInt").onInterface(INTERFACE_NAME).withOutputParamNames("anInt").implementedAs([this](){ return this->getInt(); });
         object_.registerMethod("getTuple").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getTuple(); });
 
-        object_.registerMethod("multiply").onInterface(INTERFACE_NAME).implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); });
+        object_.registerMethod("multiply").onInterface(INTERFACE_NAME).withInputParamNames("a", "b").withOutputParamNames("result").implementedAs([this](const int64_t& a, const double& b){ return this->multiply(a, b); });
         object_.registerMethod("multiplyWithNoReply").onInterface(INTERFACE_NAME).implementedAs([this](const int64_t& a, const double& b){ this->multiplyWithNoReply(a, b); }).markAsDeprecated().withNoReply();
         object_.registerMethod("getInts16FromStruct").onInterface(INTERFACE_NAME).implementedAs([this](
                 const sdbus::Struct<uint8_t, int16_t, double, std::string, std::vector<int16_t>>& x){ return this->getInts16FromStruct(x); });
 
         object_.registerMethod("processVariant").onInterface(INTERFACE_NAME).implementedAs([this](sdbus::Variant& v){ return this->processVariant(v); });
 
-        object_.registerMethod("getMapOfVariants").onInterface(INTERFACE_NAME).implementedAs([this](
+        object_.registerMethod("getMapOfVariants").onInterface(INTERFACE_NAME)
+                .withInputParamNames("x", "y").withOutputParamNames("aMapOfVariants").implementedAs([this](
                 const std::vector<int32_t>& x, const sdbus::Struct<sdbus::Variant, sdbus::Variant>& y){ return this->getMapOfVariants(x ,y); });
 
         object_.registerMethod("getStructInStruct").onInterface(INTERFACE_NAME).implementedAs([this](){ return this->getStructInStruct(); });
@@ -110,8 +111,9 @@ protected:
 
         // registration of signals is optional, it is useful because of introspection
         object_.registerSignal("simpleSignal").onInterface(INTERFACE_NAME).markAsDeprecated();
-        object_.registerSignal("signalWithMap").onInterface(INTERFACE_NAME).withParameters<std::map<int32_t, std::string>>();
-        object_.registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>();
+        // Note: sd-bus of libsystemd up to v244 has a bug where it doesn't generate signal parameter names in introspection XML. Signal param names commented temporarily.
+        object_.registerSignal("signalWithMap").onInterface(INTERFACE_NAME).withParameters<std::map<int32_t, std::string>>(/*"aMap"*/);
+        object_.registerSignal("signalWithVariant").onInterface(INTERFACE_NAME).withParameters<sdbus::Variant>(/*"aVariant"*/);
 
         object_.registerProperty("state").onInterface(INTERFACE_NAME).withGetter([this](){ return this->state(); }).markAsDeprecated().withUpdateBehavior(sdbus::Flags::CONST_PROPERTY_VALUE);
         object_.registerProperty("action").onInterface(INTERFACE_NAME).withGetter([this](){ return this->action(); }).withSetter([this](const uint32_t& value){ this->action(value); }).withUpdateBehavior(sdbus::Flags::EMITS_INVALIDATION_SIGNAL);
@@ -250,16 +252,16 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
    <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
   </method>
   <method name="getInt">
-   <arg type="i" direction="out"/>
+   <arg type="i" name="anInt" direction="out"/>
   </method>
   <method name="getInts16FromStruct">
    <arg type="(yndsan)" direction="in"/>
    <arg type="an" direction="out"/>
   </method>
   <method name="getMapOfVariants">
-   <arg type="ai" direction="in"/>
-   <arg type="(vv)" direction="in"/>
-   <arg type="a{iv}" direction="out"/>
+   <arg type="ai" name="x" direction="in"/>
+   <arg type="(vv)" name="y" direction="in"/>
+   <arg type="a{iv}" name="aMapOfVariants" direction="out"/>
   </method>
   <method name="getObjectPath">
    <arg type="o" direction="out"/>
@@ -278,9 +280,9 @@ R"delimiter(<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspectio
    <arg type="h" direction="out"/>
   </method>
   <method name="multiply">
-   <arg type="x" direction="in"/>
-   <arg type="d" direction="in"/>
-   <arg type="d" direction="out"/>
+   <arg type="x" name="a" direction="in"/>
+   <arg type="d" name="b" direction="in"/>
+   <arg type="d" name="result" direction="out"/>
   </method>
   <method name="multiplyWithNoReply">
    <arg type="x" direction="in"/>

tests/perftests/perftests-adaptor.h

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

tests/stresstests/celsius-thermometer-adaptor.h

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

tests/stresstests/concatenator-adaptor.h

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

tests/stresstests/fahrenheit-thermometer-adaptor.h

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

tools/xml2cpp-codegen/AdaptorGenerator.cpp

@@ -204,14 +204,17 @@ std::tuple<std::string, std::string> AdaptorGenerator::processMethods(const Node
         Nodes inArgs = args.select("direction" , "in");
         Nodes outArgs = args.select("direction" , "out");
 
-        std::string argStr, argTypeStr;
-        std::tie(argStr, argTypeStr, std::ignore) = argsToNamesAndTypes(inArgs, async);
+        std::string argStr, argTypeStr, argStringsStr, outArgStringsStr;
+        std::tie(argStr, argTypeStr, std::ignore, argStringsStr) = argsToNamesAndTypes(inArgs, async);
+        std::tie(std::ignore, std::ignore, std::ignore, outArgStringsStr) = argsToNamesAndTypes(outArgs);
 
         using namespace std::string_literals;
 
         registrationSS << tab << tab << "object_.registerMethod(\""
                 << methodName << "\")"
                 << ".onInterface(INTERFACE_NAME)"
+                << (!argStringsStr.empty() ? (".withInputParamNames(" + argStringsStr + ")") : "")
+                << (!outArgStringsStr.empty() ? (".withOutputParamNames(" + outArgStringsStr + ")") : "")
                 << ".implementedAs("
                 << "[this]("
                 << (async ? "sdbus::Result<" + outArgsToType(outArgs, true) + ">&& result" + (argTypeStr.empty() ? "" : ", ") : "")
@@ -259,8 +262,8 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
 
         Nodes args = (*signal)["arg"];
 
-        std::string argStr, argTypeStr, typeStr;;
-        std::tie(argStr, argTypeStr, typeStr) = argsToNamesAndTypes(args);
+        std::string argStr, argTypeStr, typeStr, argStringsStr;
+        std::tie(argStr, argTypeStr, typeStr, argStringsStr) = argsToNamesAndTypes(args);
 
         signalRegistrationSS << tab << tab
                 << "object_.registerSignal(\"" << name << "\")"
@@ -268,7 +271,7 @@ std::tuple<std::string, std::string> AdaptorGenerator::processSignals(const Node
 
         if (args.size() > 0)
         {
-            signalRegistrationSS << ".withParameters<" << typeStr << ">()";
+            signalRegistrationSS << ".withParameters<" << typeStr << ">(" << argStringsStr << ")";
         }
 
         signalRegistrationSS << annotationRegistration;

tools/xml2cpp-codegen/BaseGenerator.cpp

@@ -105,9 +105,9 @@ std::tuple<unsigned, std::string> BaseGenerator::generateNamespaces(const std::s
 }
 
 
-std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndTypes(const Nodes& args, bool async) const
+std::tuple<std::string, std::string, std::string, std::string> BaseGenerator::argsToNamesAndTypes(const Nodes& args, bool async) const
 {
-    std::ostringstream argSS, argTypeSS, typeSS;
+    std::ostringstream argSS, argTypeSS, typeSS, argStringsSS;
 
     for (size_t i = 0; i < args.size(); ++i)
     {
@@ -115,6 +115,7 @@ std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndT
         if (i > 0)
         {
             argSS << ", ";
+            argStringsSS << ", ";
             argTypeSS << ", ";
             typeSS << ", ";
         }
@@ -125,6 +126,7 @@ std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndT
             argName = "arg" + std::to_string(i);
         }
         auto type = signature_to_type(arg->get("type"));
+        argStringsSS << "\"" << argName << "\"";
         if (!async)
         {
             argSS << argName;
@@ -138,7 +140,7 @@ std::tuple<std::string, std::string, std::string> BaseGenerator::argsToNamesAndT
         typeSS << type;
     }
 
-    return std::make_tuple(argSS.str(), argTypeSS.str(), typeSS.str());
+    return std::make_tuple(argSS.str(), argTypeSS.str(), typeSS.str(), argStringsSS.str());
 }
 
 /**

tools/xml2cpp-codegen/BaseGenerator.h

@@ -88,7 +88,7 @@ protected:
      * @param args
      * @return tuple: argument names, argument types and names, argument types
      */
-    std::tuple<std::string, std::string, std::string> argsToNamesAndTypes(const sdbuscpp::xml::Nodes& args, bool async = false) const;
+    std::tuple<std::string, std::string, std::string, std::string> argsToNamesAndTypes(const sdbuscpp::xml::Nodes& args, bool async = false) const;
 
     /**
      * Output arguments to return type

tools/xml2cpp-codegen/ProxyGenerator.cpp

@@ -169,9 +169,9 @@ std::tuple<std::string, std::string> ProxyGenerator::processMethods(const Nodes&
 
         auto retType = outArgsToType(outArgs);
         std::string inArgStr, inArgTypeStr;
-        std::tie(inArgStr, inArgTypeStr, std::ignore) = argsToNamesAndTypes(inArgs);
+        std::tie(inArgStr, inArgTypeStr, std::ignore, std::ignore) = argsToNamesAndTypes(inArgs);
         std::string outArgStr, outArgTypeStr;
-        std::tie(outArgStr, outArgTypeStr, std::ignore) = argsToNamesAndTypes(outArgs);
+        std::tie(outArgStr, outArgTypeStr, std::ignore, std::ignore) = argsToNamesAndTypes(outArgs);
 
         definitionSS << tab << (async ? "void" : retType) << " " << name << "(" << inArgTypeStr << ")" << endl
                 << tab << "{" << endl;
@@ -239,7 +239,7 @@ std::tuple<std::string, std::string> ProxyGenerator::processSignals(const Nodes&
         nameBigFirst[0] = islower(nameBigFirst[0]) ? nameBigFirst[0] + 'A' - 'a' : nameBigFirst[0];
 
         std::string argStr, argTypeStr;
-        std::tie(argStr, argTypeStr, std::ignore) = argsToNamesAndTypes(args);
+        std::tie(argStr, argTypeStr, std::ignore, std::ignore) = argsToNamesAndTypes(args);
 
         registrationSS << tab << tab << "proxy_"
                 ".uponSignal(\"" << name << "\")"