Signal using custom type that has no default constructor

[LJ2911]

Hi!

I'm looking for some help with a slightly obscure use-case I currently have. In my application I have a class definition that has no default constructor and wish to keep it this way as the default constructed object would be invalid and I don't want users to be able to interact with it (and don't want to add validity checks to all methods in the class), however, I also wish to be able to use this class as an sdbus::Signal argument.

There are one or two other libraries that my application interacts with using this type and I have successfully been able to add a friend declaration to the class in order for those libraries to be able to default construct an object (using a private default constructor) as I know the data will then get correctly populated shortly after using the assignment operator. However, I am having no luck doing the same here.

My class at it's core is a wrapper for a string_view that constricts to pointing at certain static strings (that have a guaranteed lifetime) and has custom methods for interacting with it, so I implemented the following (de)serialisation methods in the sdbus namespace first:

namespace my {
sdbus::Message &operator<<(sdbus::Message &sdbusMessage, const CustomClass &custom)
    {
        return sdbusMessage << std::string{custom.GetString()};
    }

    sdbus::Message &operator>>(sdbus::Message &sdbusMessage, CustomClass &custom)
    {
        std::string string;

        sdbusMessage >> string;

        custom = CustomClass{string};

        return sdbusMessage;
    }
}

template<>
struct sdbus::signature_of<my::CustomClass> :
    sdbus::signature_of<std::string>
{
};

I have then tried adding these friend declarations to my class and have had no joy with any of them:

class CustomClass: public SomeBase
{
public:
    explicit CustomClass(const std::string_view string);
    CustomClass(const CustomClass&other);
    CustomClass &operator=(const CustomClass &other);
    CustomClass &operator=(const std::string &other);
    ~CustomClass() override;
    ...

    friend sdbus::SignalSubscriber;
    friend sdbus::Signal;
    friend std::tuple<CustomClass, int64_t>;
    friend std::tuple<std::decay_t<CustomClass>, std::decay_t<int64_t>>;
    friend sdbus::tuple_of_function_input_arg_types<const std::function<void(CustomClass, int64_t)> &>::type;

private:
    CustomClass();
};

For reference, the signal I am trying to implement has a signature void(my::CustomClass, int64_t) in case you were wondering what the std::function template args are about and I implement a wrapper for sdbus-cpp that requires a std::function to be provided as the callback which I use to std::bind member functions to in consumers. The compilation error I am getting is:

/usr/include/sdbus-c++/ConvenienceApiClasses.inl:628:60: error: no matching function for call to ‘std::tuple<my::CustomClass, long int>::tuple()’
  628 |             tuple_of_function_input_arg_types_t<_Function> signalArgs;

Also, for reference, I am using version 0.8.3-4 of this library and unfortunately don't have scope to move to a newer version at present.

[sangelovic]

@LJ2911 I think the solution with friend that you are trying is not possible. std::tuple is used to represent a list of parameters (values) in a signal. And it is first created with its default constructor (at the location pointed to by the error you referenced), so that then a signal contents can be deserialized into it. Tuple's default constructor, as per cppreference.com, requires that all the types in the tuple support default construction for it to participate in the overload resolution. Tuple uses stdlib's type traits implementation to check if all types support default construction. The type traits fail on your type. When I looked into gcc stdlib implementation, the type traits end up calling __is_nothrow_constructible(_Tp) which looks already like a compiler intrinsics/builtin functions. So I think there is no way around that with friend declarations. Additionally, even if there were a way, it would appear smelly to me.

The class used in sdbus-c++ API must either be default-constructible, or you cannot use it with sdbus-c++. Your class cannot be even used in std::tuple, for example. Do you want to limit its usage in such ways, too?

Alternative solutions that quickly come to my mind:

• a wrapper for your CustomClass that you'll use in sdbus-c++ API and that will support default construction.
• Refactor CustomClass to support the semantics of empty/invalid state (the state after default construction, or after move operation (oh yes, what about move operations?), for example). In a default-constructed state, it can for example point to a static string that is empty, to emulate the state of emptiness. Then perhaps you don't need to do precondition checks in your methods because there is always some string pointed to (just potentially an empty string). I would seriously consider this option.

[LJ2911]

Thanks for the support @sangelovic.

I ended up coming to similar conclusions around the time you responded (that due to use within a std::tuple the std::is_default_constructible evaluation needed to be true. It looks like it's technically possible to re-implement this operation, but that felt very wrong.

As such, I ended up going with your first suggestion and defined a SerialisedCustomClass that had both a default constructor and a constructor taking a CustomClass reference. This allows me to use the SerialisedCustomClass in template arguments for sdbus-cpp whilst still allowing my application to interact solely with CustomClass objects which will be implicitly converted into the serialised structure. I then make the SerialisedCustomClass structure a friend of my CustomClass.

Whilst I agree that a default constructor with an invalid state would be much simpler, the goal of this class is to try and restrict consumers to only being able to interact with valid values as these strings are written into files and we want there to be no way for empty / invalid strings to be written in (and we don't have direct control of the code that write these strings to files).