sdbus-c++  1.1.0
High-level C++ D-Bus library based on systemd D-Bus implementation
IProxy.h
Go to the documentation of this file.
1 
27 #ifndef SDBUS_CXX_IPROXY_H_
28 #define SDBUS_CXX_IPROXY_H_
29 
31 #include <string>
32 #include <memory>
33 #include <functional>
34 #include <chrono>
35 
36 // Forward declarations
37 namespace sdbus {
38  class MethodCall;
39  class MethodReply;
40  class IConnection;
41  class PendingAsyncCall;
42  namespace internal {
43  class Proxy;
44  }
45 }
46 
47 namespace sdbus {
48 
49  /********************************************/
63  class IProxy
64  {
65  public:
66  virtual ~IProxy() = default;
67 
81  virtual MethodCall createMethodCall(const std::string& interfaceName, const std::string& methodName) = 0;
82 
101  virtual MethodReply callMethod(const MethodCall& message, uint64_t timeout = 0) = 0;
102 
106  template <typename _Rep, typename _Period>
107  MethodReply callMethod(const MethodCall& message, const std::chrono::duration<_Rep, _Period>& timeout);
108 
125  virtual PendingAsyncCall callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, uint64_t timeout = 0) = 0;
126 
130  template <typename _Rep, typename _Period>
131  PendingAsyncCall callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, const std::chrono::duration<_Rep, _Period>& timeout);
132 
142  virtual void registerSignalHandler( const std::string& interfaceName
143  , const std::string& signalName
144  , signal_handler signalHandler ) = 0;
145 
154  virtual void unregisterSignalHandler( const std::string& interfaceName
155  , const std::string& signalName ) = 0;
156 
165  virtual void finishRegistration() = 0;
166 
176  virtual void unregister() = 0;
177 
197  [[nodiscard]] MethodInvoker callMethod(const std::string& methodName);
198 
221  [[nodiscard]] AsyncMethodInvoker callMethodAsync(const std::string& methodName);
222 
241  [[nodiscard]] SignalSubscriber uponSignal(const std::string& signalName);
242 
258  [[nodiscard]] SignalUnsubscriber muteSignal(const std::string& signalName);
259 
277  [[nodiscard]] PropertyGetter getProperty(const std::string& propertyName);
278 
296  [[nodiscard]] PropertySetter setProperty(const std::string& propertyName);
297 
303  virtual sdbus::IConnection& getConnection() const = 0;
304 
308  virtual const std::string& getObjectPath() const = 0;
309 
324  virtual const Message* getCurrentlyProcessedMessage() const = 0;
325  };
326 
327  /********************************************/
338  {
339  public:
340  PendingAsyncCall() = default;
341 
349  void cancel();
350 
359  bool isPending() const;
360 
361  private:
362  friend internal::Proxy;
363  PendingAsyncCall(std::weak_ptr<void> callData);
364 
365  private:
366  std::weak_ptr<void> callData_;
367  };
368 
369  // Out-of-line member definitions
370 
371  template <typename _Rep, typename _Period>
372  inline MethodReply IProxy::callMethod(const MethodCall& message, const std::chrono::duration<_Rep, _Period>& timeout)
373  {
374  auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
375  return callMethod(message, microsecs.count());
376  }
377 
378  template <typename _Rep, typename _Period>
379  inline PendingAsyncCall IProxy::callMethod(const MethodCall& message, async_reply_handler asyncReplyCallback, const std::chrono::duration<_Rep, _Period>& timeout)
380  {
381  auto microsecs = std::chrono::duration_cast<std::chrono::microseconds>(timeout);
382  return callMethod(message, std::move(asyncReplyCallback), microsecs.count());
383  }
384 
385  inline MethodInvoker IProxy::callMethod(const std::string& methodName)
386  {
387  return MethodInvoker(*this, methodName);
388  }
389 
390  inline AsyncMethodInvoker IProxy::callMethodAsync(const std::string& methodName)
391  {
392  return AsyncMethodInvoker(*this, methodName);
393  }
394 
395  inline SignalSubscriber IProxy::uponSignal(const std::string& signalName)
396  {
397  return SignalSubscriber(*this, signalName);
398  }
399 
400  inline SignalUnsubscriber IProxy::muteSignal(const std::string& signalName)
401  {
402  return SignalUnsubscriber(*this, signalName);
403  }
404 
405  inline PropertyGetter IProxy::getProperty(const std::string& propertyName)
406  {
407  return PropertyGetter(*this, propertyName);
408  }
409 
410  inline PropertySetter IProxy::setProperty(const std::string& propertyName)
411  {
412  return PropertySetter(*this, propertyName);
413  }
414 
434  [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( sdbus::IConnection& connection
435  , std::string destination
436  , std::string objectPath );
437 
457  [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::unique_ptr<sdbus::IConnection>&& connection
458  , std::string destination
459  , std::string objectPath );
460 
478  [[nodiscard]] std::unique_ptr<sdbus::IProxy> createProxy( std::string destination
479  , std::string objectPath );
480 
481 }
482 
484 
485 #endif /* SDBUS_CXX_IPROXY_H_ */
std::unique_ptr< sdbus::IProxy > createProxy(sdbus::IConnection &connection, std::string destination, std::string objectPath)
Creates a proxy object for a specific remote D-Bus object.
Definition: ConvenienceApiClasses.h:189
Definition: IConnection.h:49
Definition: IProxy.h:64
virtual void registerSignalHandler(const std::string &interfaceName, const std::string &signalName, signal_handler signalHandler)=0
Registers a handler for the desired signal emitted by the proxied D-Bus object.
virtual void unregisterSignalHandler(const std::string &interfaceName, const std::string &signalName)=0
Unregisters the handler of the desired signal.
virtual MethodCall createMethodCall(const std::string &interfaceName, const std::string &methodName)=0
Creates a method call message.
SignalUnsubscriber muteSignal(const std::string &signalName)
Unregisters signal handler of a given signal of the proxied D-Bus object.
Definition: IProxy.h:400
virtual void unregister()=0
Unregisters proxy's signal handlers and stops receving replies to pending async calls.
virtual void finishRegistration()=0
Finishes the registration of signal handlers.
virtual PendingAsyncCall callMethod(const MethodCall &message, async_reply_handler asyncReplyCallback, uint64_t timeout=0)=0
Calls method on the proxied D-Bus object asynchronously.
PropertySetter setProperty(const std::string &propertyName)
Sets value of a property of the proxied D-Bus object.
Definition: IProxy.h:410
virtual MethodReply callMethod(const MethodCall &message, uint64_t timeout=0)=0
Calls method on the proxied D-Bus object.
virtual sdbus::IConnection & getConnection() const =0
Provides D-Bus connection used by the proxy.
virtual const Message * getCurrentlyProcessedMessage() const =0
Provides currently processed D-Bus message.
AsyncMethodInvoker callMethodAsync(const std::string &methodName)
Calls method on the proxied D-Bus object asynchronously.
Definition: IProxy.h:390
virtual const std::string & getObjectPath() const =0
Returns object path of the underlying DBus object.
PropertyGetter getProperty(const std::string &propertyName)
Gets value of a property of the proxied D-Bus object.
Definition: IProxy.h:405
SignalSubscriber uponSignal(const std::string &signalName)
Registers signal handler for a given signal of the proxied D-Bus object.
Definition: IProxy.h:395
Definition: Message.h:77
Definition: Message.h:180
Definition: ConvenienceApiClasses.h:164
Definition: Message.h:209
Definition: IProxy.h:338
void cancel()
Cancels the delivery of the pending asynchronous call result.
bool isPending() const
Answers whether the asynchronous call is still pending.
Definition: ConvenienceApiClasses.h:231
Definition: ConvenienceApiClasses.h:242
Definition: ConvenienceApiClasses.h:207
Definition: ConvenienceApiClasses.h:220