1 // This file was generated by gir (https://github.com/gtk-rs/gir)
2 // from gir-files (https://github.com/gtk-rs/gir-files)
3 // DO NOT EDIT
4 
5 use crate::DBusCapabilityFlags;
6 use crate::DBusMessageByteOrder;
7 use crate::DBusMessageFlags;
8 use crate::DBusMessageHeaderField;
9 use crate::DBusMessageType;
10 #[cfg(any(unix, feature = "dox"))]
11 #[cfg_attr(feature = "dox", doc(cfg(unix)))]
12 use crate::UnixFDList;
13 #[cfg(any(unix, feature = "dox"))]
14 #[cfg_attr(feature = "dox", doc(cfg(unix)))]
15 use glib::object::IsA;
16 use glib::object::ObjectType as ObjectType_;
17 use glib::signal::connect_raw;
18 use glib::signal::SignalHandlerId;
19 use glib::translate::*;
20 use std::boxed::Box as Box_;
21 use std::mem;
22 use std::mem::transmute;
23 use std::ptr;
24 
25 glib::wrapper! {
26     #[doc(alias = "GDBusMessage")]
27     pub struct DBusMessage(Object<ffi::GDBusMessage>);
28 
29     match fn {
30         type_ => || ffi::g_dbus_message_get_type(),
31     }
32 }
33 
34 impl DBusMessage {
35     #[doc(alias = "g_dbus_message_new")]
new() -> DBusMessage36     pub fn new() -> DBusMessage {
37         unsafe { from_glib_full(ffi::g_dbus_message_new()) }
38     }
39 
40     #[doc(alias = "g_dbus_message_new_from_blob")]
41     #[doc(alias = "new_from_blob")]
from_blob( blob: &[u8], capabilities: DBusCapabilityFlags, ) -> Result<DBusMessage, glib::Error>42     pub fn from_blob(
43         blob: &[u8],
44         capabilities: DBusCapabilityFlags,
45     ) -> Result<DBusMessage, glib::Error> {
46         let blob_len = blob.len() as usize;
47         unsafe {
48             let mut error = ptr::null_mut();
49             let ret = ffi::g_dbus_message_new_from_blob(
50                 blob.to_glib_none().0,
51                 blob_len,
52                 capabilities.into_glib(),
53                 &mut error,
54             );
55             if error.is_null() {
56                 Ok(from_glib_full(ret))
57             } else {
58                 Err(from_glib_full(error))
59             }
60         }
61     }
62 
63     #[doc(alias = "g_dbus_message_new_method_call")]
new_method_call( name: Option<&str>, path: &str, interface_: Option<&str>, method: &str, ) -> DBusMessage64     pub fn new_method_call(
65         name: Option<&str>,
66         path: &str,
67         interface_: Option<&str>,
68         method: &str,
69     ) -> DBusMessage {
70         unsafe {
71             from_glib_full(ffi::g_dbus_message_new_method_call(
72                 name.to_glib_none().0,
73                 path.to_glib_none().0,
74                 interface_.to_glib_none().0,
75                 method.to_glib_none().0,
76             ))
77         }
78     }
79 
80     #[doc(alias = "g_dbus_message_new_signal")]
new_signal(path: &str, interface_: &str, signal: &str) -> DBusMessage81     pub fn new_signal(path: &str, interface_: &str, signal: &str) -> DBusMessage {
82         unsafe {
83             from_glib_full(ffi::g_dbus_message_new_signal(
84                 path.to_glib_none().0,
85                 interface_.to_glib_none().0,
86                 signal.to_glib_none().0,
87             ))
88         }
89     }
90 
91     #[doc(alias = "g_dbus_message_copy")]
copy(&self) -> Result<DBusMessage, glib::Error>92     pub fn copy(&self) -> Result<DBusMessage, glib::Error> {
93         unsafe {
94             let mut error = ptr::null_mut();
95             let ret = ffi::g_dbus_message_copy(self.to_glib_none().0, &mut error);
96             if error.is_null() {
97                 Ok(from_glib_full(ret))
98             } else {
99                 Err(from_glib_full(error))
100             }
101         }
102     }
103 
104     #[doc(alias = "g_dbus_message_get_arg0")]
105     #[doc(alias = "get_arg0")]
arg0(&self) -> Option<glib::GString>106     pub fn arg0(&self) -> Option<glib::GString> {
107         unsafe { from_glib_none(ffi::g_dbus_message_get_arg0(self.to_glib_none().0)) }
108     }
109 
110     #[doc(alias = "g_dbus_message_get_body")]
111     #[doc(alias = "get_body")]
body(&self) -> Option<glib::Variant>112     pub fn body(&self) -> Option<glib::Variant> {
113         unsafe { from_glib_none(ffi::g_dbus_message_get_body(self.to_glib_none().0)) }
114     }
115 
116     #[doc(alias = "g_dbus_message_get_byte_order")]
117     #[doc(alias = "get_byte_order")]
byte_order(&self) -> DBusMessageByteOrder118     pub fn byte_order(&self) -> DBusMessageByteOrder {
119         unsafe { from_glib(ffi::g_dbus_message_get_byte_order(self.to_glib_none().0)) }
120     }
121 
122     #[doc(alias = "g_dbus_message_get_destination")]
123     #[doc(alias = "get_destination")]
destination(&self) -> Option<glib::GString>124     pub fn destination(&self) -> Option<glib::GString> {
125         unsafe { from_glib_none(ffi::g_dbus_message_get_destination(self.to_glib_none().0)) }
126     }
127 
128     #[doc(alias = "g_dbus_message_get_error_name")]
129     #[doc(alias = "get_error_name")]
error_name(&self) -> Option<glib::GString>130     pub fn error_name(&self) -> Option<glib::GString> {
131         unsafe { from_glib_none(ffi::g_dbus_message_get_error_name(self.to_glib_none().0)) }
132     }
133 
134     #[doc(alias = "g_dbus_message_get_flags")]
135     #[doc(alias = "get_flags")]
flags(&self) -> DBusMessageFlags136     pub fn flags(&self) -> DBusMessageFlags {
137         unsafe { from_glib(ffi::g_dbus_message_get_flags(self.to_glib_none().0)) }
138     }
139 
140     #[doc(alias = "g_dbus_message_get_header")]
141     #[doc(alias = "get_header")]
header(&self, header_field: DBusMessageHeaderField) -> Option<glib::Variant>142     pub fn header(&self, header_field: DBusMessageHeaderField) -> Option<glib::Variant> {
143         unsafe {
144             from_glib_none(ffi::g_dbus_message_get_header(
145                 self.to_glib_none().0,
146                 header_field.into_glib(),
147             ))
148         }
149     }
150 
151     #[doc(alias = "g_dbus_message_get_interface")]
152     #[doc(alias = "get_interface")]
interface(&self) -> Option<glib::GString>153     pub fn interface(&self) -> Option<glib::GString> {
154         unsafe { from_glib_none(ffi::g_dbus_message_get_interface(self.to_glib_none().0)) }
155     }
156 
157     #[doc(alias = "g_dbus_message_get_locked")]
158     #[doc(alias = "get_locked")]
is_locked(&self) -> bool159     pub fn is_locked(&self) -> bool {
160         unsafe { from_glib(ffi::g_dbus_message_get_locked(self.to_glib_none().0)) }
161     }
162 
163     #[doc(alias = "g_dbus_message_get_member")]
164     #[doc(alias = "get_member")]
member(&self) -> Option<glib::GString>165     pub fn member(&self) -> Option<glib::GString> {
166         unsafe { from_glib_none(ffi::g_dbus_message_get_member(self.to_glib_none().0)) }
167     }
168 
169     #[doc(alias = "g_dbus_message_get_message_type")]
170     #[doc(alias = "get_message_type")]
message_type(&self) -> DBusMessageType171     pub fn message_type(&self) -> DBusMessageType {
172         unsafe { from_glib(ffi::g_dbus_message_get_message_type(self.to_glib_none().0)) }
173     }
174 
175     #[cfg(any(unix, feature = "dox"))]
176     #[cfg_attr(feature = "dox", doc(cfg(unix)))]
177     #[doc(alias = "g_dbus_message_get_num_unix_fds")]
178     #[doc(alias = "get_num_unix_fds")]
num_unix_fds(&self) -> u32179     pub fn num_unix_fds(&self) -> u32 {
180         unsafe { ffi::g_dbus_message_get_num_unix_fds(self.to_glib_none().0) }
181     }
182 
183     #[doc(alias = "g_dbus_message_get_path")]
184     #[doc(alias = "get_path")]
path(&self) -> Option<glib::GString>185     pub fn path(&self) -> Option<glib::GString> {
186         unsafe { from_glib_none(ffi::g_dbus_message_get_path(self.to_glib_none().0)) }
187     }
188 
189     #[doc(alias = "g_dbus_message_get_reply_serial")]
190     #[doc(alias = "get_reply_serial")]
reply_serial(&self) -> u32191     pub fn reply_serial(&self) -> u32 {
192         unsafe { ffi::g_dbus_message_get_reply_serial(self.to_glib_none().0) }
193     }
194 
195     #[doc(alias = "g_dbus_message_get_sender")]
196     #[doc(alias = "get_sender")]
sender(&self) -> Option<glib::GString>197     pub fn sender(&self) -> Option<glib::GString> {
198         unsafe { from_glib_none(ffi::g_dbus_message_get_sender(self.to_glib_none().0)) }
199     }
200 
201     #[doc(alias = "g_dbus_message_get_serial")]
202     #[doc(alias = "get_serial")]
serial(&self) -> u32203     pub fn serial(&self) -> u32 {
204         unsafe { ffi::g_dbus_message_get_serial(self.to_glib_none().0) }
205     }
206 
207     #[doc(alias = "g_dbus_message_get_signature")]
208     #[doc(alias = "get_signature")]
signature(&self) -> glib::GString209     pub fn signature(&self) -> glib::GString {
210         unsafe { from_glib_none(ffi::g_dbus_message_get_signature(self.to_glib_none().0)) }
211     }
212 
213     #[cfg(any(unix, feature = "dox"))]
214     #[cfg_attr(feature = "dox", doc(cfg(unix)))]
215     #[doc(alias = "g_dbus_message_get_unix_fd_list")]
216     #[doc(alias = "get_unix_fd_list")]
unix_fd_list(&self) -> Option<UnixFDList>217     pub fn unix_fd_list(&self) -> Option<UnixFDList> {
218         unsafe { from_glib_none(ffi::g_dbus_message_get_unix_fd_list(self.to_glib_none().0)) }
219     }
220 
221     #[doc(alias = "g_dbus_message_lock")]
lock(&self)222     pub fn lock(&self) {
223         unsafe {
224             ffi::g_dbus_message_lock(self.to_glib_none().0);
225         }
226     }
227 
228     //#[doc(alias = "g_dbus_message_new_method_error")]
229     //pub fn new_method_error(&self, error_name: &str, error_message_format: &str, : /*Unknown conversion*//*Unimplemented*/Fundamental: VarArgs) -> DBusMessage {
230     //    unsafe { TODO: call ffi:g_dbus_message_new_method_error() }
231     //}
232 
233     #[doc(alias = "g_dbus_message_new_method_error_literal")]
new_method_error_literal(&self, error_name: &str, error_message: &str) -> DBusMessage234     pub fn new_method_error_literal(&self, error_name: &str, error_message: &str) -> DBusMessage {
235         unsafe {
236             from_glib_full(ffi::g_dbus_message_new_method_error_literal(
237                 self.to_glib_none().0,
238                 error_name.to_glib_none().0,
239                 error_message.to_glib_none().0,
240             ))
241         }
242     }
243 
244     //#[doc(alias = "g_dbus_message_new_method_error_valist")]
245     //pub fn new_method_error_valist(&self, error_name: &str, error_message_format: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) -> DBusMessage {
246     //    unsafe { TODO: call ffi:g_dbus_message_new_method_error_valist() }
247     //}
248 
249     #[doc(alias = "g_dbus_message_new_method_reply")]
new_method_reply(&self) -> DBusMessage250     pub fn new_method_reply(&self) -> DBusMessage {
251         unsafe { from_glib_full(ffi::g_dbus_message_new_method_reply(self.to_glib_none().0)) }
252     }
253 
254     #[doc(alias = "g_dbus_message_print")]
print(&self, indent: u32) -> glib::GString255     pub fn print(&self, indent: u32) -> glib::GString {
256         unsafe { from_glib_full(ffi::g_dbus_message_print(self.to_glib_none().0, indent)) }
257     }
258 
259     #[doc(alias = "g_dbus_message_set_body")]
set_body(&self, body: &glib::Variant)260     pub fn set_body(&self, body: &glib::Variant) {
261         unsafe {
262             ffi::g_dbus_message_set_body(self.to_glib_none().0, body.to_glib_none().0);
263         }
264     }
265 
266     #[doc(alias = "g_dbus_message_set_byte_order")]
set_byte_order(&self, byte_order: DBusMessageByteOrder)267     pub fn set_byte_order(&self, byte_order: DBusMessageByteOrder) {
268         unsafe {
269             ffi::g_dbus_message_set_byte_order(self.to_glib_none().0, byte_order.into_glib());
270         }
271     }
272 
273     #[doc(alias = "g_dbus_message_set_destination")]
set_destination(&self, value: Option<&str>)274     pub fn set_destination(&self, value: Option<&str>) {
275         unsafe {
276             ffi::g_dbus_message_set_destination(self.to_glib_none().0, value.to_glib_none().0);
277         }
278     }
279 
280     #[doc(alias = "g_dbus_message_set_error_name")]
set_error_name(&self, value: &str)281     pub fn set_error_name(&self, value: &str) {
282         unsafe {
283             ffi::g_dbus_message_set_error_name(self.to_glib_none().0, value.to_glib_none().0);
284         }
285     }
286 
287     #[doc(alias = "g_dbus_message_set_flags")]
set_flags(&self, flags: DBusMessageFlags)288     pub fn set_flags(&self, flags: DBusMessageFlags) {
289         unsafe {
290             ffi::g_dbus_message_set_flags(self.to_glib_none().0, flags.into_glib());
291         }
292     }
293 
294     #[doc(alias = "g_dbus_message_set_header")]
set_header(&self, header_field: DBusMessageHeaderField, value: Option<&glib::Variant>)295     pub fn set_header(&self, header_field: DBusMessageHeaderField, value: Option<&glib::Variant>) {
296         unsafe {
297             ffi::g_dbus_message_set_header(
298                 self.to_glib_none().0,
299                 header_field.into_glib(),
300                 value.to_glib_none().0,
301             );
302         }
303     }
304 
305     #[doc(alias = "g_dbus_message_set_interface")]
set_interface(&self, value: Option<&str>)306     pub fn set_interface(&self, value: Option<&str>) {
307         unsafe {
308             ffi::g_dbus_message_set_interface(self.to_glib_none().0, value.to_glib_none().0);
309         }
310     }
311 
312     #[doc(alias = "g_dbus_message_set_member")]
set_member(&self, value: Option<&str>)313     pub fn set_member(&self, value: Option<&str>) {
314         unsafe {
315             ffi::g_dbus_message_set_member(self.to_glib_none().0, value.to_glib_none().0);
316         }
317     }
318 
319     #[doc(alias = "g_dbus_message_set_message_type")]
set_message_type(&self, type_: DBusMessageType)320     pub fn set_message_type(&self, type_: DBusMessageType) {
321         unsafe {
322             ffi::g_dbus_message_set_message_type(self.to_glib_none().0, type_.into_glib());
323         }
324     }
325 
326     #[cfg(any(unix, feature = "dox"))]
327     #[cfg_attr(feature = "dox", doc(cfg(unix)))]
328     #[doc(alias = "g_dbus_message_set_num_unix_fds")]
set_num_unix_fds(&self, value: u32)329     pub fn set_num_unix_fds(&self, value: u32) {
330         unsafe {
331             ffi::g_dbus_message_set_num_unix_fds(self.to_glib_none().0, value);
332         }
333     }
334 
335     #[doc(alias = "g_dbus_message_set_path")]
set_path(&self, value: Option<&str>)336     pub fn set_path(&self, value: Option<&str>) {
337         unsafe {
338             ffi::g_dbus_message_set_path(self.to_glib_none().0, value.to_glib_none().0);
339         }
340     }
341 
342     #[doc(alias = "g_dbus_message_set_reply_serial")]
set_reply_serial(&self, value: u32)343     pub fn set_reply_serial(&self, value: u32) {
344         unsafe {
345             ffi::g_dbus_message_set_reply_serial(self.to_glib_none().0, value);
346         }
347     }
348 
349     #[doc(alias = "g_dbus_message_set_sender")]
set_sender(&self, value: Option<&str>)350     pub fn set_sender(&self, value: Option<&str>) {
351         unsafe {
352             ffi::g_dbus_message_set_sender(self.to_glib_none().0, value.to_glib_none().0);
353         }
354     }
355 
356     #[doc(alias = "g_dbus_message_set_serial")]
set_serial(&self, serial: u32)357     pub fn set_serial(&self, serial: u32) {
358         unsafe {
359             ffi::g_dbus_message_set_serial(self.to_glib_none().0, serial);
360         }
361     }
362 
363     #[doc(alias = "g_dbus_message_set_signature")]
set_signature(&self, value: Option<&str>)364     pub fn set_signature(&self, value: Option<&str>) {
365         unsafe {
366             ffi::g_dbus_message_set_signature(self.to_glib_none().0, value.to_glib_none().0);
367         }
368     }
369 
370     #[cfg(any(unix, feature = "dox"))]
371     #[cfg_attr(feature = "dox", doc(cfg(unix)))]
372     #[doc(alias = "g_dbus_message_set_unix_fd_list")]
set_unix_fd_list<P: IsA<UnixFDList>>(&self, fd_list: Option<&P>)373     pub fn set_unix_fd_list<P: IsA<UnixFDList>>(&self, fd_list: Option<&P>) {
374         unsafe {
375             ffi::g_dbus_message_set_unix_fd_list(
376                 self.to_glib_none().0,
377                 fd_list.map(|p| p.as_ref()).to_glib_none().0,
378             );
379         }
380     }
381 
382     #[doc(alias = "g_dbus_message_to_blob")]
to_blob(&self, capabilities: DBusCapabilityFlags) -> Result<Vec<u8>, glib::Error>383     pub fn to_blob(&self, capabilities: DBusCapabilityFlags) -> Result<Vec<u8>, glib::Error> {
384         unsafe {
385             let mut out_size = mem::MaybeUninit::uninit();
386             let mut error = ptr::null_mut();
387             let ret = ffi::g_dbus_message_to_blob(
388                 self.to_glib_none().0,
389                 out_size.as_mut_ptr(),
390                 capabilities.into_glib(),
391                 &mut error,
392             );
393             if error.is_null() {
394                 Ok(FromGlibContainer::from_glib_full_num(
395                     ret,
396                     out_size.assume_init() as usize,
397                 ))
398             } else {
399                 Err(from_glib_full(error))
400             }
401         }
402     }
403 
404     #[doc(alias = "g_dbus_message_to_gerror")]
to_gerror(&self) -> Result<(), glib::Error>405     pub fn to_gerror(&self) -> Result<(), glib::Error> {
406         unsafe {
407             let mut error = ptr::null_mut();
408             let _ = ffi::g_dbus_message_to_gerror(self.to_glib_none().0, &mut error);
409             if error.is_null() {
410                 Ok(())
411             } else {
412                 Err(from_glib_full(error))
413             }
414         }
415     }
416 
417     #[doc(alias = "g_dbus_message_bytes_needed")]
bytes_needed(blob: &[u8]) -> Result<isize, glib::Error>418     pub fn bytes_needed(blob: &[u8]) -> Result<isize, glib::Error> {
419         let blob_len = blob.len() as usize;
420         unsafe {
421             let mut error = ptr::null_mut();
422             let ret = ffi::g_dbus_message_bytes_needed(blob.to_glib_none().0, blob_len, &mut error);
423             if error.is_null() {
424                 Ok(ret)
425             } else {
426                 Err(from_glib_full(error))
427             }
428         }
429     }
430 
431     #[doc(alias = "locked")]
connect_locked_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId432     pub fn connect_locked_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
433         unsafe extern "C" fn notify_locked_trampoline<F: Fn(&DBusMessage) + 'static>(
434             this: *mut ffi::GDBusMessage,
435             _param_spec: glib::ffi::gpointer,
436             f: glib::ffi::gpointer,
437         ) {
438             let f: &F = &*(f as *const F);
439             f(&from_glib_borrow(this))
440         }
441         unsafe {
442             let f: Box_<F> = Box_::new(f);
443             connect_raw(
444                 self.as_ptr() as *mut _,
445                 b"notify::locked\0".as_ptr() as *const _,
446                 Some(transmute::<_, unsafe extern "C" fn()>(
447                     notify_locked_trampoline::<F> as *const (),
448                 )),
449                 Box_::into_raw(f),
450             )
451         }
452     }
453 }
454 
455 impl Default for DBusMessage {
default() -> Self456     fn default() -> Self {
457         Self::new()
458     }
459 }
460