1 #include <sdeventplus/internal/sdevent.hpp>
2 #include <systemd/sd-event.h>
3 
4 namespace sdeventplus
5 {
6 namespace internal
7 {
8 
9 int SdEventImpl::sd_event_default(sd_event** event) const
10 {
11     return ::sd_event_default(event);
12 }
13 
14 int SdEventImpl::sd_event_new(sd_event** event) const
15 {
16     return ::sd_event_default(event);
17 }
18 
19 sd_event* SdEventImpl::sd_event_ref(sd_event* event) const
20 {
21     return ::sd_event_ref(event);
22 }
23 
24 sd_event* SdEventImpl::sd_event_unref(sd_event* event) const
25 {
26     return ::sd_event_unref(event);
27 }
28 
29 int SdEventImpl::sd_event_add_io(sd_event* event, sd_event_source** source,
30                                  int fd, uint32_t events,
31                                  sd_event_io_handler_t callback,
32                                  void* userdata) const
33 {
34     return ::sd_event_add_io(event, source, fd, events, callback, userdata);
35 }
36 
37 int SdEventImpl::sd_event_add_time(sd_event* event, sd_event_source** source,
38                                    clockid_t clock, uint64_t usec,
39                                    uint64_t accuracy,
40                                    sd_event_time_handler_t callback,
41                                    void* userdata) const
42 {
43     return ::sd_event_add_time(event, source, clock, usec, accuracy, callback,
44                                userdata);
45 }
46 
47 int SdEventImpl::sd_event_add_defer(sd_event* event, sd_event_source** source,
48                                     sd_event_handler_t callback,
49                                     void* userdata) const
50 {
51     return ::sd_event_add_defer(event, source, callback, userdata);
52 }
53 
54 int SdEventImpl::sd_event_add_post(sd_event* event, sd_event_source** source,
55                                    sd_event_handler_t callback,
56                                    void* userdata) const
57 {
58     return ::sd_event_add_post(event, source, callback, userdata);
59 }
60 
61 int SdEventImpl::sd_event_add_exit(sd_event* event, sd_event_source** source,
62                                    sd_event_handler_t callback,
63                                    void* userdata) const
64 {
65     return ::sd_event_add_exit(event, source, callback, userdata);
66 }
67 
68 int SdEventImpl::sd_event_prepare(sd_event* event) const
69 {
70     return ::sd_event_prepare(event);
71 }
72 
73 int SdEventImpl::sd_event_wait(sd_event* event, uint64_t usec) const
74 {
75     return ::sd_event_wait(event, usec);
76 }
77 
78 int SdEventImpl::sd_event_dispatch(sd_event* event) const
79 {
80     return ::sd_event_dispatch(event);
81 }
82 
83 int SdEventImpl::sd_event_run(sd_event* event, uint64_t usec) const
84 {
85     return ::sd_event_run(event, usec);
86 }
87 
88 int SdEventImpl::sd_event_loop(sd_event* event) const
89 {
90     return ::sd_event_loop(event);
91 }
92 
93 int SdEventImpl::sd_event_exit(sd_event* event, int code) const
94 {
95     return ::sd_event_exit(event, code);
96 }
97 
98 int SdEventImpl::sd_event_now(sd_event* event, clockid_t clock,
99                               uint64_t* usec) const
100 {
101     return ::sd_event_now(event, clock, usec);
102 }
103 
104 int SdEventImpl::sd_event_get_exit_code(sd_event* event, int* code) const
105 {
106     return ::sd_event_get_exit_code(event, code);
107 }
108 
109 int SdEventImpl::sd_event_get_watchdog(sd_event* event) const
110 {
111     return ::sd_event_get_watchdog(event);
112 }
113 
114 int SdEventImpl::sd_event_set_watchdog(sd_event* event, int b) const
115 {
116     return ::sd_event_set_watchdog(event, b);
117 }
118 
119 sd_event_source* SdEventImpl::sd_event_source_ref(sd_event_source* source) const
120 {
121     return ::sd_event_source_ref(source);
122 }
123 
124 sd_event_source*
125     SdEventImpl::sd_event_source_unref(sd_event_source* source) const
126 {
127     return ::sd_event_source_unref(source);
128 }
129 
130 void* SdEventImpl::sd_event_source_get_userdata(sd_event_source* source) const
131 {
132     return ::sd_event_source_get_userdata(source);
133 }
134 
135 void* SdEventImpl::sd_event_source_set_userdata(sd_event_source* source,
136                                                 void* userdata) const
137 {
138     return ::sd_event_source_set_userdata(source, userdata);
139 }
140 
141 int SdEventImpl::sd_event_source_get_description(sd_event_source* source,
142                                                  const char** description) const
143 {
144     return ::sd_event_source_get_description(source, description);
145 }
146 
147 int SdEventImpl::sd_event_source_set_description(sd_event_source* source,
148                                                  const char* description) const
149 {
150     return ::sd_event_source_set_description(source, description);
151 }
152 
153 int SdEventImpl::sd_event_source_set_prepare(sd_event_source* source,
154                                              sd_event_handler_t callback) const
155 {
156     return ::sd_event_source_set_prepare(source, callback);
157 }
158 
159 int SdEventImpl::sd_event_source_get_pending(sd_event_source* source) const
160 {
161     return ::sd_event_source_get_pending(source);
162 }
163 
164 int SdEventImpl::sd_event_source_get_priority(sd_event_source* source,
165                                               int64_t* priority) const
166 {
167     return ::sd_event_source_get_priority(source, priority);
168 }
169 
170 int SdEventImpl::sd_event_source_set_priority(sd_event_source* source,
171                                               int64_t priority) const
172 {
173     return ::sd_event_source_set_priority(source, priority);
174 }
175 
176 int SdEventImpl::sd_event_source_get_enabled(sd_event_source* source,
177                                              int* enabled) const
178 {
179     return ::sd_event_source_get_enabled(source, enabled);
180 }
181 
182 int SdEventImpl::sd_event_source_set_enabled(sd_event_source* source,
183                                              int enabled) const
184 {
185     return ::sd_event_source_set_enabled(source, enabled);
186 }
187 
188 int SdEventImpl::sd_event_source_get_io_fd(sd_event_source* source) const
189 {
190     return ::sd_event_source_get_io_fd(source);
191 }
192 
193 int SdEventImpl::sd_event_source_set_io_fd(sd_event_source* source,
194                                            int fd) const
195 {
196     return ::sd_event_source_set_io_fd(source, fd);
197 }
198 
199 int SdEventImpl::sd_event_source_get_io_events(sd_event_source* source,
200                                                uint32_t* events) const
201 {
202     return ::sd_event_source_get_io_events(source, events);
203 }
204 
205 int SdEventImpl::sd_event_source_set_io_events(sd_event_source* source,
206                                                uint32_t events) const
207 {
208     return ::sd_event_source_set_io_events(source, events);
209 }
210 
211 int SdEventImpl::sd_event_source_get_io_revents(sd_event_source* source,
212                                                 uint32_t* revents) const
213 {
214     return ::sd_event_source_get_io_revents(source, revents);
215 }
216 
217 int SdEventImpl::sd_event_source_get_time(sd_event_source* source,
218                                           uint64_t* usec) const
219 {
220     return ::sd_event_source_get_time(source, usec);
221 }
222 
223 int SdEventImpl::sd_event_source_set_time(sd_event_source* source,
224                                           uint64_t usec) const
225 {
226     return ::sd_event_source_set_time(source, usec);
227 }
228 
229 int SdEventImpl::sd_event_source_get_time_accuracy(sd_event_source* source,
230                                                    uint64_t* usec) const
231 {
232     return ::sd_event_source_get_time_accuracy(source, usec);
233 }
234 
235 int SdEventImpl::sd_event_source_set_time_accuracy(sd_event_source* source,
236                                                    uint64_t usec) const
237 {
238     return ::sd_event_source_set_time_accuracy(source, usec);
239 }
240 
241 int SdEventImpl::sd_event_source_get_signal(sd_event_source* source) const
242 {
243     return ::sd_event_source_get_signal(source);
244 }
245 
246 int SdEventImpl::sd_event_source_get_child_pid(sd_event_source* source,
247                                                pid_t* pid) const
248 {
249     return ::sd_event_source_get_child_pid(source, pid);
250 }
251 
252 int SdEventImpl::sd_event_source_set_destroy_callback(
253     sd_event_source* source, sd_event_destroy_t callback) const
254 {
255     return ::sd_event_source_set_destroy_callback(source, callback);
256 }
257 
258 int SdEventImpl::sd_event_source_get_destroy_callback(
259     sd_event_source* source, sd_event_destroy_t* callback) const
260 {
261     return ::sd_event_source_get_destroy_callback(source, callback);
262 }
263 
264 int SdEventImpl::sd_event_source_set_floating(sd_event_source* source,
265                                               int b) const
266 {
267     return ::sd_event_source_set_floating(source, b);
268 }
269 
270 int SdEventImpl::sd_event_source_get_floating(sd_event_source* source) const
271 {
272     return ::sd_event_source_get_floating(source);
273 }
274 
275 SdEventImpl sdevent_impl;
276 
277 } // namespace internal
278 } // namespace sdeventplus
279