sdbus-c++ 2.1.0
High-level C++ D-Bus library based on systemd D-Bus implementation
Loading...
Searching...
No Matches
ConvenienceApiClasses.h
Go to the documentation of this file.
1
26
27#ifndef SDBUS_CXX_CONVENIENCEAPICLASSES_H_
28#define SDBUS_CXX_CONVENIENCEAPICLASSES_H_
29
30#include <sdbus-c++/Message.h>
32#include <sdbus-c++/Types.h>
34
35#include <chrono>
36#include <cstdint>
37#include <future>
38#include <map>
39#include <string>
40#include <string_view>
41#include <vector>
42
43// Forward declarations
44namespace sdbus {
45 class IObject;
46 class IProxy;
47 class Error;
48 class PendingAsyncCall;
49}
50
51namespace sdbus {
52
53 class VTableAdder
54 {
55 public:
56 void forInterface(InterfaceName interfaceName);
57 void forInterface(std::string interfaceName);
58 [[nodiscard]] Slot forInterface(InterfaceName interfaceName, return_slot_t);
59 [[nodiscard]] Slot forInterface(std::string interfaceName, return_slot_t);
60
61 private:
62 friend IObject;
63 VTableAdder(IObject& object, std::vector<VTableItem> vtable);
64
65 private:
66 IObject& object_;
67 std::vector<VTableItem> vtable_;
68 };
69
70 class SignalEmitter
71 {
72 public:
73 SignalEmitter& onInterface(const InterfaceName& interfaceName);
74 SignalEmitter& onInterface(const std::string& interfaceName);
75 SignalEmitter& onInterface(const char* interfaceName);
76 template <typename... _Args> void withArguments(_Args&&... args);
77
78 SignalEmitter(SignalEmitter&& other) = default;
79 ~SignalEmitter() noexcept(false);
80
81 private:
82 friend IObject;
83 SignalEmitter(IObject& object, const SignalName& signalName);
84 SignalEmitter(IObject& object, const char* signalName);
85
86 private:
87 IObject& object_;
88 const char* signalName_;
89 Signal signal_;
90 int exceptions_{}; // Number of active exceptions when SignalEmitter is constructed
91 };
92
93 class MethodInvoker
94 {
95 public:
96 MethodInvoker& onInterface(const InterfaceName& interfaceName);
97 MethodInvoker& onInterface(const std::string& interfaceName);
98 MethodInvoker& onInterface(const char* interfaceName);
99 MethodInvoker& withTimeout(uint64_t usec);
100 template <typename _Rep, typename _Period>
101 MethodInvoker& withTimeout(const std::chrono::duration<_Rep, _Period>& timeout);
102 template <typename... _Args> MethodInvoker& withArguments(_Args&&... args);
103 template <typename... _Args> void storeResultsTo(_Args&... args);
104 void dontExpectReply();
105
106 MethodInvoker(MethodInvoker&& other) = default;
107 ~MethodInvoker() noexcept(false);
108
109 private:
110 friend IProxy;
111 MethodInvoker(IProxy& proxy, const MethodName& methodName);
112 MethodInvoker(IProxy& proxy, const char* methodName);
113
114 private:
115 IProxy& proxy_;
116 const char* methodName_;
117 uint64_t timeout_{};
118 MethodCall method_;
119 int exceptions_{}; // Number of active exceptions when MethodInvoker is constructed
120 bool methodCalled_{};
121 };
122
123 class AsyncMethodInvoker
124 {
125 public:
126 AsyncMethodInvoker& onInterface(const InterfaceName& interfaceName);
127 AsyncMethodInvoker& onInterface(const std::string& interfaceName);
128 AsyncMethodInvoker& onInterface(const char* interfaceName);
129 AsyncMethodInvoker& withTimeout(uint64_t usec);
130 template <typename _Rep, typename _Period>
131 AsyncMethodInvoker& withTimeout(const std::chrono::duration<_Rep, _Period>& timeout);
132 template <typename... _Args> AsyncMethodInvoker& withArguments(_Args&&... args);
133 template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
134 template <typename _Function> [[nodiscard]] Slot uponReplyInvoke(_Function&& callback, return_slot_t);
135 // Returned future will be std::future<void> for no (void) D-Bus method return value
136 // or std::future<T> for single D-Bus method return value
137 // or std::future<std::tuple<...>> for multiple method return values
138 template <typename... _Args> std::future<future_return_t<_Args...>> getResultAsFuture();
139
140 private:
141 friend IProxy;
142 AsyncMethodInvoker(IProxy& proxy, const MethodName& methodName);
143 AsyncMethodInvoker(IProxy& proxy, const char* methodName);
144 template <typename _Function> async_reply_handler makeAsyncReplyHandler(_Function&& callback);
145
146 private:
147 IProxy& proxy_;
148 const char* methodName_;
149 uint64_t timeout_{};
150 MethodCall method_;
151 };
152
153 class SignalSubscriber
154 {
155 public:
156 SignalSubscriber& onInterface(const InterfaceName& interfaceName);
157 SignalSubscriber& onInterface(const std::string& interfaceName);
158 SignalSubscriber& onInterface(const char* interfaceName);
159 template <typename _Function> void call(_Function&& callback);
160 template <typename _Function> [[nodiscard]] Slot call(_Function&& callback, return_slot_t);
161
162 private:
163 friend IProxy;
164 SignalSubscriber(IProxy& proxy, const SignalName& signalName);
165 SignalSubscriber(IProxy& proxy, const char* signalName);
166 template <typename _Function> signal_handler makeSignalHandler(_Function&& callback);
167
168 private:
169 IProxy& proxy_;
170 const char* signalName_;
171 const char* interfaceName_{};
172 };
173
174 class PropertyGetter
175 {
176 public:
177 Variant onInterface(std::string_view interfaceName);
178
179 private:
180 friend IProxy;
181 PropertyGetter(IProxy& proxy, std::string_view propertyName);
182
183 static constexpr const char* DBUS_PROPERTIES_INTERFACE_NAME = "org.freedesktop.DBus.Properties";
184
185 private:
186 IProxy& proxy_;
187 std::string_view propertyName_;
188 };
189
190 class AsyncPropertyGetter
191 {
192 public:
193 AsyncPropertyGetter& onInterface(std::string_view interfaceName);
194 template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
195 template <typename _Function> [[nodiscard]] Slot uponReplyInvoke(_Function&& callback, return_slot_t);
196 std::future<Variant> getResultAsFuture();
197
198 private:
199 friend IProxy;
200 AsyncPropertyGetter(IProxy& proxy, std::string_view propertyName);
201
202 static constexpr const char* DBUS_PROPERTIES_INTERFACE_NAME = "org.freedesktop.DBus.Properties";
203
204 private:
205 IProxy& proxy_;
206 std::string_view propertyName_;
207 std::string_view interfaceName_;
208 };
209
210 class PropertySetter
211 {
212 public:
213 PropertySetter& onInterface(std::string_view interfaceName);
214 template <typename _Value> void toValue(const _Value& value);
215 template <typename _Value> void toValue(const _Value& value, dont_expect_reply_t);
216 void toValue(const Variant& value);
217 void toValue(const Variant& value, dont_expect_reply_t);
218
219 private:
220 friend IProxy;
221 PropertySetter(IProxy& proxy, std::string_view propertyName);
222
223 static constexpr const char* DBUS_PROPERTIES_INTERFACE_NAME = "org.freedesktop.DBus.Properties";
224
225 private:
226 IProxy& proxy_;
227 std::string_view propertyName_;
228 std::string_view interfaceName_;
229 };
230
231 class AsyncPropertySetter
232 {
233 public:
234 AsyncPropertySetter& onInterface(std::string_view interfaceName);
235 template <typename _Value> AsyncPropertySetter& toValue(_Value&& value);
236 AsyncPropertySetter& toValue(Variant value);
237 template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
238 template <typename _Function> [[nodiscard]] Slot uponReplyInvoke(_Function&& callback, return_slot_t);
239 std::future<void> getResultAsFuture();
240
241 private:
242 friend IProxy;
243 AsyncPropertySetter(IProxy& proxy, std::string_view propertyName);
244
245 static constexpr const char* DBUS_PROPERTIES_INTERFACE_NAME = "org.freedesktop.DBus.Properties";
246
247 private:
248 IProxy& proxy_;
249 std::string_view propertyName_;
250 std::string_view interfaceName_;
251 Variant value_;
252 };
253
254 class AllPropertiesGetter
255 {
256 public:
257 std::map<PropertyName, Variant> onInterface(std::string_view interfaceName);
258
259 private:
260 friend IProxy;
261 AllPropertiesGetter(IProxy& proxy);
262
263 static constexpr const char* DBUS_PROPERTIES_INTERFACE_NAME = "org.freedesktop.DBus.Properties";
264
265 private:
266 IProxy& proxy_;
267 };
268
269 class AsyncAllPropertiesGetter
270 {
271 public:
272 AsyncAllPropertiesGetter& onInterface(std::string_view interfaceName);
273 template <typename _Function> PendingAsyncCall uponReplyInvoke(_Function&& callback);
274 template <typename _Function> [[nodiscard]] Slot uponReplyInvoke(_Function&& callback, return_slot_t);
275 std::future<std::map<PropertyName, Variant>> getResultAsFuture();
276
277 private:
278 friend IProxy;
279 AsyncAllPropertiesGetter(IProxy& proxy);
280
281 static constexpr const char* DBUS_PROPERTIES_INTERFACE_NAME = "org.freedesktop.DBus.Properties";
282
283 private:
284 IProxy& proxy_;
285 std::string_view interfaceName_;
286 };
287
288} // namespace sdbus
289
290#endif /* SDBUS_CXX_CONVENIENCEAPICLASSES_H_ */
Definition Error.h:44
Definition IObject.h:63
Definition IProxy.h:69
Definition Types.h:238
Definition Message.h:267
Definition IProxy.h:676
Definition Message.h:302
Definition Types.h:57
Definition TypeTraits.h:107
Definition TypeTraits.h:88