IProxy.h

Go to the documentation of this file.

 
#ifndef SDBUS_CXX_IPROXY_H_
#define SDBUS_CXX_IPROXY_H_
 
#include <sdbus-c++/ConvenienceApiClasses.h>
#include <string>
#include <memory>
#include <functional>
#include <chrono>
 
// Forward declarations
namespace sdbus {
    class MethodCall;
    class MethodReply;
    class IConnection;
    class PendingAsyncCall;
    namespace internal {
        class Proxy;
    }
}
 
namespace sdbus {
 
    /********************************************/
    class IProxy
    {
    public:
        virtual ~IProxy() = default;
 
        virtual MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;
 
        virtual MethodReply callMethod(const MethodCall& message, uint64_t timeout = 0) = 0;
 
        template <typename _Rep, typename _Period>
        MethodReply callMethod(const MethodCall& message, const std::chrono::duration<_Rep, _Period>& timeout);
 
        virtual PendingAsyncCall callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout = 0) = 0;
 
        template <typename _Rep, typename _Period>
        PendingAsyncCall callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, const std::chrono::duration<_Rep, _Period>& timeout);
 
        virtual void registerSignalHandler( const std::string& interfaceName
                                          , const std::string& signalName
                                          , signal_handler signalHandler ) = 0;
 
        virtual void finishRegistration() = 0;
 
        virtual void unregister() = 0;
 
        [[nodiscard]] MethodInvoker callMethod(const std::string& methodName);
 
        [[nodiscard]] AsyncMethodInvoker callMethodAsync(const std::string& methodName);
 
        [[nodiscard]] SignalSubscriber uponSignal(const std::string& signalName);
 
        [[nodiscard]] PropertyGetter getProperty(const std::string& propertyName);
 
        [[nodiscard]] PropertySetter setProperty(const std::string& propertyName);
 
        virtual sdbus::IConnection& getConnection() const = 0;
 
        virtual const std::string& getObjectPath() const = 0;
 
        virtual const Message* getCurrentlyProcessedMessage() const = 0;
    };
 
    /********************************************/
    class PendingAsyncCall
    {
    public:
        PendingAsyncCall() = default;
 
        void cancel();
 
        bool isPending() const;
 
    private:
        friend internal::Proxy;
        PendingAsyncCall(std::weak_ptr<void> callData);
 
    private:
        std::weak_ptr<void> callData_;
    };
 
    // Out-of-line member definitions
 
    template <typename _Rep, typename _Period>
    inline MethodReply IProxy::callMethod(const MethodCall& message, const std::chrono::duration<_Rep, _Period>& timeout)
    {
        auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
        return callMethod(message, microsecs.count());
    }
 
    template <typename _Rep, typename _Period>
    inline PendingAsyncCall IProxy::callMethod(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());
    }
 
    inline MethodInvoker IProxy::callMethod(const std::string& methodName)
    {
        return MethodInvoker(*this, methodName);
    }
 
    inline AsyncMethodInvoker IProxy::callMethodAsync(const std::string& methodName)
    {
        return AsyncMethodInvoker(*this, methodName);
    }
 
    inline SignalSubscriber IProxy::uponSignal(const std::string& signalName)
    {
        return SignalSubscriber(*this, signalName);
    }
 
    inline PropertyGetter IProxy::getProperty(const std::string& propertyName)
    {
        return PropertyGetter(*this, propertyName);
    }
 
    inline PropertySetter IProxy::setProperty(const std::string& propertyName)
    {
        return PropertySetter(*this, propertyName);
    }
 
    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( sdbus::IConnection& connection
                                                            , std::string destination
                                                            , std::string objectPath );
 
    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<sdbus::IConnection>&& connection
                                                            , std::string destination
                                                            , std::string objectPath );
 
    [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
                                                            , std::string objectPath );
 
}
 
#include <sdbus-c++/ConvenienceApiClasses.inl>
 
#endif /* SDBUS_CXX_IPROXY_H_ */