sdbus-c++ 1.1.0
High-level C++ D-Bus library based on systemd D-Bus implementation
Loading...
Searching...
No Matches
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
37namespace sdbus {
38 class MethodCall;
39 class MethodReply;
40 class IConnection;
41 class PendingAsyncCall;
42 namespace internal {
43 class Proxy;
44 }
45}
46
47namespace 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 const Message * getCurrentlyProcessedMessage() const =0
Provides currently processed D-Bus message.
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.
virtual const std::string & getObjectPath() const =0
Returns object path of the underlying DBus object.
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.
AsyncMethodInvoker callMethodAsync(const std::string &methodName)
Calls method on the proxied D-Bus object asynchronously.
Definition: IProxy.h:390
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