Is destoring dbus object thread safe?

[Snarpix]

If I have understood correctly destroying object is currently not thread safe.

Let's look at example(modified, from https://github.com/Kistler-Group/sdbus-cpp/blob/master/docs/using-sdbus-c++.md):

class Concatenator : public sdbus::AdaptorInterfaces<org::sdbuscpp::Concatenator_adaptor /*, more adaptor classes if there are more interfaces*/>
{
public:
    Concatenator(sdbus::IConnection& connection, std::string objectPath)
        : AdaptorInterfaces(connection, std::move(objectPath))
    {
        registerAdaptor();
    }

    ~Concatenator()
    {
        unregisterAdaptor();
    }
   
   const std::string member_ = "12313123213";

protected:
    std::string concatenate(const std::vector<int32_t>& numbers, const std::string& separator) override
    {
            std::this_thread::sleep_for(300s);
           return member_;
    }
};

In this case calling unregisterAdaptor will stop new calls to concatenate method from happening, but if some call is already waiting on std::this_thread::sleep_for(300s); then when wait finishes it will access member_, which was already destroyed.

Is my reasoning correct?

[sangelovic]

Hello, no, it's not correct. The Object instance will not be destroyed as long as there are calls being served by that object. This is guaranteed by internal thread safety design of sdbus-c++. Thread safety chapter discusses this to some detail. It says it's completely safe to destroy Object and Proxy instances at any time. This of course counts with the fact that there may be operations pending on those instances at that very same time -- these operations are finished first and then the object is destroyed.

So in your case, the thread destructing the object would wait for at most 300 seconds until the event loop thread serving the object finishes serving the call.