sdbus::Struct definition possible in XML?

[michab66]

I' m working with code that defines structures using the sdbus::Struct type. This is used in the definition of signals in the withParameters-call. See the definition of the structs in the source below.

Is a structure definition also possible when the dbus-interface is defined in XML?

I know that structures can be defined in XML like

<method name="notify">
            <arg type="a(ssiiia(a(is(sa(dd))i)a(is(sa(dd))i))b(siays)(siays)isssa{s(ss)}a(isssssssi)sba{ss})iq" ... />
            ...
</method>

I'm looking for an option to define structures in a more human readable format in the XML similiar to the following C++ code.

using DBusSettingExtraInfoStruct
        = sdbus::Struct<std::string, std::string, bool, bool, std::string, std::string>;

using DBusSubSettingStruct = sdbus::Struct<std::string, std::string, bool>;

 using DBusSettingStruct = sdbus::Struct<
        bool,
        std::string,
        std::string,
        bool,
        bool,
        bool,
        DBusSettingExtraInfoStruct,
        bool,
        bool,
        bool,
        bool,
        bool,
        std::vector<DBusSubSettingStruct>,
        bool,
        std::vector<DBusSettingExtraInfoStruct>>;

[12-3-8-s9b9o9j9t]

To get a struct you can use parentheses in the xml
For example type="(osb)" will make use of the type sdbus::Struct<sdbus::ObjectPath, std::string, bool>

[michab66]

I think my question is not clear enough, see the edit.

[sangelovic]

@michab66

Is a structure definition also possible when the dbus-interface is defined in XML?

I found nothing in the official D-Bus XML introspection format specification on defining custom typedefs for D-Bus structs. AFAICS it's not supported.

You can define typedefs yourself in your final proxy class -- the one that inherits from ProxyInterfaces class template, and then, for higher readability, use these in your code when calling methods of the class.

Is it acceptable for you?

A potential solution on sdbus-c++ part that comes to mind is to introduce a custom extension in the XML (because these can be extended beyond specification). Either through annotation (these can be extended):

<method name="notify">
    <arg type="a(ssiiia(a(is(sa(dd))i)a(is(sa(dd))i))b(siays)(siays)isssa{s(ss)}a(isssssssi)sba{ss})iq" ... >
        <annotation name="org.freedesktop.SdBusCpp.TypeAlias" value="DBusSettingStruct" />
    </arg>
    ...
</method>

Or through additional custom attribute (not sure if that is allowed or would not break some validators or such things):

<method name="notify">
    <arg type="a(ssiiia(a(is(sa(dd))i)a(is(sa(dd))i))b(siays)(siays)isssa{s(ss)}a(isssssssi)sba{ss})iq" typealias="DBusSettingStruct" ... />
    ...
</method>

The codegen could then collect all such type aliases and create typedefs in the generated class like so:

class whatever_proxy
{
public:
    ...
    using DBusSettingStruct = sdbus::Struct<bool, std::string, std::string, bool, ..., std::vector<DBusSettingExtraInfoStruct>>;
    ...

public:
    void notify(const DBusSettingStruct& arg, ...)
    {
        ...
    }

    ...
};

sdbus-c++ already has custom annotations, so this is not a problem. But beware that if you get an XML by introspecting a service, you'd have to add these annotations yourself to the XML since they would be a custom extension.

What do you think?

[michab66]

To give more context: I'm working a lot with qface-defined servers. A qface-example can be found here.

Currently we define your clients based on the bindings that were generated from the qface-definitions. This is where these very complex types like
type="a(ssiiia(a(is(sa(dd))i)a(is(sa(dd))i))b(siays)(siays)isssa{s(ss)}a(isssssssi)sba{ss})iq" are coming from. The using= type definitions as the one shown in my initial question are then created manually for sdbus-c++. And sdbus-c++ has the great feature to be able to use this directly when creating the bindings programmatically:

        getObject()
            .registerSignal(Xxx::Dbus::Descriptors::SNotificatSigSettingsChanged)
            .onInterface(Xxx::Dbus::Descriptors::SNotificationInterfaceName)
            .withParameters<
                std::vector<DBusSettingWrapper::DBusSettingStruct>, // <- Here is the place where the structured type is used.
                int32_t,
                std::uint16_t>(
                Xxx::Dbus::Descriptors::SNotificationNewValueArgName,
                Xxx::Dbus::Descriptors::SNotificationSeatIdArgName,
                Xxx::Dbus::Descriptors::SNotificationClientIdArgName);

This is error prone, when the qface-based interface definition changes.

Since many of our dbus interfaces are defined in sdbus-c++ xml, I am looking for a way to define structures directly in the .xml file, which seems not to be possible currently.

One solution would be to extend the sdbus-c++ binding generator to support structure definitions, for example

<struct name="DBusSettingStruct">
  <attribute name="isWritable" type="bool"/> <- primitve
  <attribute name="settingName" type="string"/>
  ...
  <attribute name="extras" type="DBusSettingExtraInfoStruct"> <- complex type
  ...
</struct>

<method name="setDbusSettings">
  <arg type="DbusSettingStruct" name="words" direction="in" />
  <arg type="s" name="result" direction="out" />
</method>

The above xml would create a C++ struct that can be used in client code to access the structure elements and in dbus-methods as parameters, as well as anything that is generated currently.

Questions are:

• Is it possible to extend the xml?
• Would it be preferrable to create a qface-based generator that builds sdbus-c++ bindings?
• Does a qface-based generator for sdbus-c++ already exist?
• Is there another option to simplify the definition of those highy complex types in an interface file?