gio/auto/

dbus_message.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

#[cfg(unix)]
#[cfg_attr(docsrs, doc(cfg(unix)))]
use crate::UnixFDList;
use crate::{
    DBusCapabilityFlags, DBusMessageByteOrder, DBusMessageFlags, DBusMessageHeaderField,
    DBusMessageType, ffi,
};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A type for representing D-Bus messages that can be sent or received
    /// on a [`DBusConnection`][crate::DBusConnection].
    ///
    /// ## Properties
    ///
    ///
    /// #### `locked`
    ///  Readable
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "GDBusMessage")]
    pub struct DBusMessage(Object<ffi::GDBusMessage>);

    match fn {
        type_ => || ffi::g_dbus_message_get_type(),
    }
}

impl DBusMessage {
    /// Creates a new empty D-Bus message.
    ///
    /// # Returns
    ///
    /// The D-Bus message
    #[doc(alias = "g_dbus_message_new")]
    pub fn new() -> DBusMessage {
        unsafe { from_glib_full(ffi::g_dbus_message_new()) }
    }

    /// Creates a new D-Bus message from the data stored at @blob.
    ///
    /// You must have previously called [`bytes_needed()`][Self::bytes_needed()] on @blob,
    /// and ensure that @blob is at least as long as the return value from that
    /// function indicates. In particular, that means that @blob must be at least 16
    /// bytes long (but will typically be much longer).
    ///
    /// The byte order that the message was in can be retrieved using
    /// [`byte_order()`][Self::byte_order()].
    ///
    /// If the @blob cannot be parsed, contains invalid fields, or contains invalid
    /// headers, [error@Gio.IOErrorEnum.INVALID_ARGUMENT] will be returned.
    /// ## `blob`
    /// a blob representing a
    ///   binary D-Bus message
    /// ## `capabilities`
    /// flags describing what protocol features are supported
    ///
    /// # Returns
    ///
    /// The D-Bus message
    #[doc(alias = "g_dbus_message_new_from_blob")]
    #[doc(alias = "new_from_blob")]
    pub fn from_blob(
        blob: &[u8],
        capabilities: DBusCapabilityFlags,
    ) -> Result<DBusMessage, glib::Error> {
        let blob_len = blob.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_message_new_from_blob(
                blob.to_glib_none().0,
                blob_len,
                capabilities.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a new D-Bus message for a method call.
    /// ## `name`
    /// a valid D-Bus name, or `NULL` if no destination is needed
    /// ## `path`
    /// a valid object path
    /// ## `interface_`
    /// a valid D-Bus interface name, or `NULL` if none is
    ///   needed
    /// ## `method`
    /// a valid method name
    ///
    /// # Returns
    ///
    /// The D-Bus message
    #[doc(alias = "g_dbus_message_new_method_call")]
    pub fn new_method_call(
        name: Option<&str>,
        path: &str,
        interface_: Option<&str>,
        method: &str,
    ) -> DBusMessage {
        unsafe {
            from_glib_full(ffi::g_dbus_message_new_method_call(
                name.to_glib_none().0,
                path.to_glib_none().0,
                interface_.to_glib_none().0,
                method.to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "g_dbus_message_new_method_error")]
    //pub fn new_method_error(method_call_message: &DBusMessage, error_name: &str, error_message_format: &str, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) -> DBusMessage {
    //    unsafe { TODO: call ffi:g_dbus_message_new_method_error() }
    //}

    /// Creates a new D-Bus message for a signal emission.
    /// ## `path`
    /// a valid object path
    /// ## `interface_`
    /// a valid D-Bus interface name
    /// ## `signal`
    /// a valid signal name
    ///
    /// # Returns
    ///
    /// The D-Bus message
    #[doc(alias = "g_dbus_message_new_signal")]
    pub fn new_signal(path: &str, interface_: &str, signal: &str) -> DBusMessage {
        unsafe {
            from_glib_full(ffi::g_dbus_message_new_signal(
                path.to_glib_none().0,
                interface_.to_glib_none().0,
                signal.to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "g_dbus_message_copy")]
    pub fn copy(&self) -> Result<DBusMessage, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_message_copy(self.to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Convenience to get the first item in the body of @self.
    ///
    /// See [`arg0_path()`][Self::arg0_path()] for returning object-path-typed
    /// arg0 values.
    ///
    /// # Returns
    ///
    /// The string item, or `NULL` if the first item in the body
    ///   of @self is not a string
    #[doc(alias = "g_dbus_message_get_arg0")]
    #[doc(alias = "get_arg0")]
    pub fn arg0(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_arg0(self.to_glib_none().0)) }
    }

    /// Convenience to get the first item in the body of @self.
    ///
    /// See [`arg0()`][Self::arg0()] for returning string-typed arg0 values.
    ///
    /// # Returns
    ///
    /// The object path item, or `NULL` if the first item in the
    ///   body of @self is not an object path
    #[cfg(feature = "v2_80")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
    #[doc(alias = "g_dbus_message_get_arg0_path")]
    #[doc(alias = "get_arg0_path")]
    pub fn arg0_path(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_arg0_path(self.to_glib_none().0)) }
    }

    /// Gets the body of a message.
    ///
    /// # Returns
    ///
    /// A [type@GLib.Variant], or `NULL` if the
    ///   body is empty
    #[doc(alias = "g_dbus_message_get_body")]
    #[doc(alias = "get_body")]
    pub fn body(&self) -> Option<glib::Variant> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_body(self.to_glib_none().0)) }
    }

    /// Gets the byte order of @self.
    ///
    /// # Returns
    ///
    /// The byte order
    #[doc(alias = "g_dbus_message_get_byte_order")]
    #[doc(alias = "get_byte_order")]
    pub fn byte_order(&self) -> DBusMessageByteOrder {
        unsafe { from_glib(ffi::g_dbus_message_get_byte_order(self.to_glib_none().0)) }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.DESTINATION]
    /// header field.
    ///
    /// # Returns
    ///
    /// The value
    #[doc(alias = "g_dbus_message_get_destination")]
    #[doc(alias = "get_destination")]
    pub fn destination(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_destination(self.to_glib_none().0)) }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.ERROR_NAME]
    /// header field.
    ///
    /// # Returns
    ///
    /// The value
    #[doc(alias = "g_dbus_message_get_error_name")]
    #[doc(alias = "get_error_name")]
    pub fn error_name(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_error_name(self.to_glib_none().0)) }
    }

    /// Gets the flags for @self.
    ///
    /// # Returns
    ///
    /// Flags that are set (typically values from the
    ///   [`DBusMessageFlags`][crate::DBusMessageFlags] enumeration bitwise ORed together)
    #[doc(alias = "g_dbus_message_get_flags")]
    #[doc(alias = "get_flags")]
    pub fn flags(&self) -> DBusMessageFlags {
        unsafe { from_glib(ffi::g_dbus_message_get_flags(self.to_glib_none().0)) }
    }

    /// Gets a header field on @self.
    ///
    /// The caller is responsible for checking the type of the returned
    /// [type@GLib.Variant] matches what is expected.
    /// ## `header_field`
    /// a 8-bit unsigned integer (typically a value from the
    ///   [`DBusMessageHeaderField`][crate::DBusMessageHeaderField] enumeration)
    ///
    /// # Returns
    ///
    /// A [type@GLib.Variant] with the value, or
    ///   `NULL` if the header was not found
    #[doc(alias = "g_dbus_message_get_header")]
    #[doc(alias = "get_header")]
    pub fn header(&self, header_field: DBusMessageHeaderField) -> Option<glib::Variant> {
        unsafe {
            from_glib_none(ffi::g_dbus_message_get_header(
                self.to_glib_none().0,
                header_field.into_glib(),
            ))
        }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.INTERFACE] header
    /// field.
    ///
    /// # Returns
    ///
    /// The value
    #[doc(alias = "g_dbus_message_get_interface")]
    #[doc(alias = "get_interface")]
    pub fn interface(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_interface(self.to_glib_none().0)) }
    }

    /// Checks whether @self is locked.
    ///
    /// To monitor changes to this value, connect to the
    /// [`notify`][struct@crate::glib::Object#notify] signal to listen for changes on the
    /// [`locked`][struct@crate::DBusMessage#locked] property.
    ///
    /// # Returns
    ///
    /// true if @self is locked, false otherwise
    #[doc(alias = "g_dbus_message_get_locked")]
    #[doc(alias = "get_locked")]
    #[doc(alias = "locked")]
    pub fn is_locked(&self) -> bool {
        unsafe { from_glib(ffi::g_dbus_message_get_locked(self.to_glib_none().0)) }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.MEMBER] header
    /// field.
    ///
    /// # Returns
    ///
    /// The value
    #[doc(alias = "g_dbus_message_get_member")]
    #[doc(alias = "get_member")]
    pub fn member(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_member(self.to_glib_none().0)) }
    }

    /// Gets the type of @self.
    ///
    /// # Returns
    ///
    /// A 8-bit unsigned integer (typically a value from the
    ///   [`DBusMessageType`][crate::DBusMessageType] enumeration)
    #[doc(alias = "g_dbus_message_get_message_type")]
    #[doc(alias = "get_message_type")]
    pub fn message_type(&self) -> DBusMessageType {
        unsafe { from_glib(ffi::g_dbus_message_get_message_type(self.to_glib_none().0)) }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.NUM_UNIX_FDS]
    /// header field.
    ///
    /// # Returns
    ///
    /// The value
    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    #[doc(alias = "g_dbus_message_get_num_unix_fds")]
    #[doc(alias = "get_num_unix_fds")]
    pub fn num_unix_fds(&self) -> u32 {
        unsafe { ffi::g_dbus_message_get_num_unix_fds(self.to_glib_none().0) }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.PATH] header
    /// field.
    ///
    /// # Returns
    ///
    /// The value
    #[doc(alias = "g_dbus_message_get_path")]
    #[doc(alias = "get_path")]
    pub fn path(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_path(self.to_glib_none().0)) }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.REPLY_SERIAL]
    /// header field.
    ///
    /// # Returns
    ///
    /// The value
    #[doc(alias = "g_dbus_message_get_reply_serial")]
    #[doc(alias = "get_reply_serial")]
    pub fn reply_serial(&self) -> u32 {
        unsafe { ffi::g_dbus_message_get_reply_serial(self.to_glib_none().0) }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.SENDER] header
    /// field.
    ///
    /// # Returns
    ///
    /// The value
    #[doc(alias = "g_dbus_message_get_sender")]
    #[doc(alias = "get_sender")]
    pub fn sender(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_sender(self.to_glib_none().0)) }
    }

    /// Gets the serial for @self.
    ///
    /// # Returns
    ///
    /// The serial number, which should not be zero
    #[doc(alias = "g_dbus_message_get_serial")]
    #[doc(alias = "get_serial")]
    pub fn serial(&self) -> u32 {
        unsafe { ffi::g_dbus_message_get_serial(self.to_glib_none().0) }
    }

    /// Convenience getter for the [enum@Gio.DBusMessageHeaderField.SIGNATURE header
    /// field.
    ///
    /// This will always be non-`NULL`, but may be an empty string.
    ///
    /// # Returns
    ///
    /// The value
    #[doc(alias = "g_dbus_message_get_signature")]
    #[doc(alias = "get_signature")]
    pub fn signature(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::g_dbus_message_get_signature(self.to_glib_none().0)) }
    }

    /// Gets the UNIX file descriptors associated with @self, if any.
    ///
    /// This method is only available on UNIX.
    ///
    /// The file descriptors normally correspond to `G_VARIANT_TYPE_HANDLE`
    /// values in the body of the message. For example, if
    /// [`glib::Variant::handle()`][crate::glib::Variant::handle()] returns 5, that is intended to be a
    /// reference to the file descriptor that can be accessed by
    /// `g_unix_fd_list_get (list, 5, ...)`.
    ///
    /// # Returns
    ///
    /// A [`UnixFDList`][crate::UnixFDList] or `NULL` if no
    ///   file descriptors are associated
    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    #[doc(alias = "g_dbus_message_get_unix_fd_list")]
    #[doc(alias = "get_unix_fd_list")]
    pub fn unix_fd_list(&self) -> Option<UnixFDList> {
        unsafe { from_glib_none(ffi::g_dbus_message_get_unix_fd_list(self.to_glib_none().0)) }
    }

    /// Locks the message.
    ///
    /// If @self is locked already, this does nothing.
    #[doc(alias = "g_dbus_message_lock")]
    pub fn lock(&self) {
        unsafe {
            ffi::g_dbus_message_lock(self.to_glib_none().0);
        }
    }

    /// Creates a new D-Bus message that is an error reply to @self.
    /// ## `error_name`
    /// a valid D-Bus error name
    /// ## `error_message`
    /// the D-Bus error message
    ///
    /// # Returns
    ///
    /// The D-Bus message
    #[doc(alias = "g_dbus_message_new_method_error_literal")]
    #[must_use]
    pub fn new_method_error_literal(&self, error_name: &str, error_message: &str) -> DBusMessage {
        unsafe {
            from_glib_full(ffi::g_dbus_message_new_method_error_literal(
                self.to_glib_none().0,
                error_name.to_glib_none().0,
                error_message.to_glib_none().0,
            ))
        }
    }

    //#[doc(alias = "g_dbus_message_new_method_error_valist")]
    //#[must_use]
    //pub fn new_method_error_valist(&self, error_name: &str, error_message_format: &str, var_args: /*Unknown conversion*//*Unimplemented*/Unsupported) -> DBusMessage {
    //    unsafe { TODO: call ffi:g_dbus_message_new_method_error_valist() }
    //}

    /// Creates a new D-Bus message that is a reply to @self.
    ///
    /// # Returns
    ///
    /// The D-Bus message
    #[doc(alias = "g_dbus_message_new_method_reply")]
    #[must_use]
    pub fn new_method_reply(&self) -> DBusMessage {
        unsafe { from_glib_full(ffi::g_dbus_message_new_method_reply(self.to_glib_none().0)) }
    }

    /// Produces a human-readable multi-line description of @self.
    ///
    /// The contents and formatting are subject to change at any time and no ABI
    /// guarantees are given. Typical output looks something like this:
    /// ```text
    /// Flags:   none
    /// Version: 0
    /// Serial:  4
    /// Headers:
    ///   path -> objectpath '/org/gtk/GDBus/TestObject'
    ///   interface -> 'org.gtk.GDBus.TestInterface'
    ///   member -> 'GimmeStdout'
    ///   destination -> ':1.146'
    /// Body: ()
    /// UNIX File Descriptors:
    ///   (none)
    /// ```
    /// or
    /// ```text
    /// Flags:   no-reply-expected
    /// Version: 0
    /// Serial:  477
    /// Headers:
    ///   reply-serial -> uint32 4
    ///   destination -> ':1.159'
    ///   sender -> ':1.146'
    ///   num-unix-fds -> uint32 1
    /// Body: ()
    /// UNIX File Descriptors:
    ///   fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
    /// ```
    /// ## `indent`
    /// indentation level
    ///
    /// # Returns
    ///
    /// Human readable description
    ///   of @self
    #[doc(alias = "g_dbus_message_print")]
    pub fn print(&self, indent: u32) -> glib::GString {
        unsafe { from_glib_full(ffi::g_dbus_message_print(self.to_glib_none().0, indent)) }
    }

    /// Sets the body of @self.
    ///
    /// As a side-effect the [enum@Gio.DBusMessageHeaderField.SIGNATURE] header field
    ///   is set to the type string of @body (or cleared if @body is `NULL`).
    ///
    /// If @body is floating, @self assumes ownership of @body.
    /// ## `body`
    /// a [type@GLib.Variant] containing a tuple, or `NULL` if no body is
    ///   needed
    #[doc(alias = "g_dbus_message_set_body")]
    pub fn set_body(&self, body: &glib::Variant) {
        unsafe {
            ffi::g_dbus_message_set_body(self.to_glib_none().0, body.to_glib_none().0);
        }
    }

    /// Sets the byte order of @self.
    /// ## `byte_order`
    /// the byte order
    #[doc(alias = "g_dbus_message_set_byte_order")]
    pub fn set_byte_order(&self, byte_order: DBusMessageByteOrder) {
        unsafe {
            ffi::g_dbus_message_set_byte_order(self.to_glib_none().0, byte_order.into_glib());
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.DESTINATION]
    /// header field.
    /// ## `value`
    /// the value to set
    #[doc(alias = "g_dbus_message_set_destination")]
    pub fn set_destination(&self, value: Option<&str>) {
        unsafe {
            ffi::g_dbus_message_set_destination(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.ERROR_NAME]
    /// header field.
    /// ## `value`
    /// the value to set
    #[doc(alias = "g_dbus_message_set_error_name")]
    pub fn set_error_name(&self, value: Option<&str>) {
        unsafe {
            ffi::g_dbus_message_set_error_name(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    /// Sets the flags to set on @self.
    /// ## `flags`
    /// flags for @self that are set (typically values from the
    ///   [`DBusMessageFlags`][crate::DBusMessageFlags] enumeration bitwise ORed together)
    #[doc(alias = "g_dbus_message_set_flags")]
    pub fn set_flags(&self, flags: DBusMessageFlags) {
        unsafe {
            ffi::g_dbus_message_set_flags(self.to_glib_none().0, flags.into_glib());
        }
    }

    /// Sets a header field on @self.
    ///
    /// If @value is floating, @self assumes ownership of @value.
    /// ## `header_field`
    /// a 8-bit unsigned integer (typically a value from the
    ///   [`DBusMessageHeaderField`][crate::DBusMessageHeaderField] enumeration)
    /// ## `value`
    /// a [type@GLib.Variant] to set the header field, or `NULL`
    ///   to clear the header field.
    #[doc(alias = "g_dbus_message_set_header")]
    pub fn set_header(&self, header_field: DBusMessageHeaderField, value: Option<&glib::Variant>) {
        unsafe {
            ffi::g_dbus_message_set_header(
                self.to_glib_none().0,
                header_field.into_glib(),
                value.to_glib_none().0,
            );
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.INTERFACE] header
    /// field.
    /// ## `value`
    /// the value to set
    #[doc(alias = "g_dbus_message_set_interface")]
    pub fn set_interface(&self, value: Option<&str>) {
        unsafe {
            ffi::g_dbus_message_set_interface(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.MEMBER] header
    /// field.
    /// ## `value`
    /// the value to set
    #[doc(alias = "g_dbus_message_set_member")]
    pub fn set_member(&self, value: Option<&str>) {
        unsafe {
            ffi::g_dbus_message_set_member(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    /// Sets @self to be of @type_.
    /// ## `type_`
    /// a 8-bit unsigned integer (typically a value from the
    ///   [`DBusMessageType`][crate::DBusMessageType] enumeration)
    #[doc(alias = "g_dbus_message_set_message_type")]
    pub fn set_message_type(&self, type_: DBusMessageType) {
        unsafe {
            ffi::g_dbus_message_set_message_type(self.to_glib_none().0, type_.into_glib());
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.NUM_UNIX_FDS]
    /// header field.
    /// ## `value`
    /// the value to set
    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    #[doc(alias = "g_dbus_message_set_num_unix_fds")]
    pub fn set_num_unix_fds(&self, value: u32) {
        unsafe {
            ffi::g_dbus_message_set_num_unix_fds(self.to_glib_none().0, value);
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.PATH] header
    /// field.
    /// ## `value`
    /// the value to set
    #[doc(alias = "g_dbus_message_set_path")]
    pub fn set_path(&self, value: Option<&str>) {
        unsafe {
            ffi::g_dbus_message_set_path(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.REPLY_SERIAL]
    /// header field.
    /// ## `value`
    /// the value to set
    #[doc(alias = "g_dbus_message_set_reply_serial")]
    pub fn set_reply_serial(&self, value: u32) {
        unsafe {
            ffi::g_dbus_message_set_reply_serial(self.to_glib_none().0, value);
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.SENDER] header
    /// field.
    /// ## `value`
    /// the value to set
    #[doc(alias = "g_dbus_message_set_sender")]
    pub fn set_sender(&self, value: Option<&str>) {
        unsafe {
            ffi::g_dbus_message_set_sender(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    /// Sets the serial for @self.
    ///
    /// The [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-messages)
    /// does not allow the @serial to be zero.
    /// ## `serial`
    /// a serial number, which must not be zero
    #[doc(alias = "g_dbus_message_set_serial")]
    pub fn set_serial(&self, serial: u32) {
        unsafe {
            ffi::g_dbus_message_set_serial(self.to_glib_none().0, serial);
        }
    }

    /// Convenience setter for the [enum@Gio.DBusMessageHeaderField.SIGNATURE] header
    /// field.
    /// ## `value`
    /// the value to set
    #[doc(alias = "g_dbus_message_set_signature")]
    pub fn set_signature(&self, value: Option<&str>) {
        unsafe {
            ffi::g_dbus_message_set_signature(self.to_glib_none().0, value.to_glib_none().0);
        }
    }

    /// Sets the UNIX file descriptors associated with @self.
    ///
    /// As a side-effect the [enum@Gio.DBusMessageHeaderField.NUM_UNIX_FDS] header
    /// field is set to the number of fds in @fd_list (or cleared if
    /// @fd_list is `NULL`).
    ///
    /// This method is only available on UNIX.
    ///
    /// When designing D-Bus APIs that are intended to be interoperable,
    /// please note that non-GDBus implementations of D-Bus can usually only
    /// access file descriptors if they are referenced by a value of type
    /// `G_VARIANT_TYPE_HANDLE` in the body of the message.
    /// ## `fd_list`
    /// A [`UnixFDList`][crate::UnixFDList], or `NULL` to clear
    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    #[doc(alias = "g_dbus_message_set_unix_fd_list")]
    pub fn set_unix_fd_list(&self, fd_list: Option<&impl IsA<UnixFDList>>) {
        unsafe {
            ffi::g_dbus_message_set_unix_fd_list(
                self.to_glib_none().0,
                fd_list.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Serializes @self to a blob.
    ///
    /// The byte order returned by [`byte_order()`][Self::byte_order()] will be
    /// used.
    /// ## `capabilities`
    /// flags describing what protocol features are supported
    ///
    /// # Returns
    ///
    /// A pointer to a
    ///   valid binary D-Bus message of @out_size bytes generated by @self
    #[doc(alias = "g_dbus_message_to_blob")]
    pub fn to_blob(&self, capabilities: DBusCapabilityFlags) -> Result<Vec<u8>, glib::Error> {
        unsafe {
            let mut out_size = std::mem::MaybeUninit::uninit();
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_message_to_blob(
                self.to_glib_none().0,
                out_size.as_mut_ptr(),
                capabilities.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibContainer::from_glib_full_num(
                    ret,
                    out_size.assume_init() as _,
                ))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Encodes the error in @self as a [type@GLib.Error].
    ///
    /// If @self is of type [enum@Gio.DBusMessageType.ERROR], this function
    /// calls `Gio::DBusError::set_dbus_error()` using the information in the
    /// [enum@Gio.DBusMessageHeaderField.ERROR_NAME] header field of @self as
    /// well as the first string item in @self’s body.
    ///
    /// If @self is not of type [enum@Gio.DBusMessageType.ERROR], this function
    /// does nothing and returns false.
    ///
    /// # Returns
    ///
    /// true if @error was set, false otherwise
    #[doc(alias = "g_dbus_message_to_gerror")]
    pub fn to_gerror(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_dbus_message_to_gerror(self.to_glib_none().0, &mut error);
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Utility function to calculate how many bytes are needed to
    /// completely deserialize the D-Bus message stored at @blob.
    ///
    /// An error will be returned if @blob contains invalid data, or if not enough
    /// data is available to determine the size.
    /// ## `blob`
    /// a blob representing a
    ///   binary D-Bus message.
    ///
    /// # Returns
    ///
    /// Number of bytes needed or `-1` if @error is set
    #[doc(alias = "g_dbus_message_bytes_needed")]
    pub fn bytes_needed(blob: &[u8]) -> Result<isize, glib::Error> {
        let blob_len = blob.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_dbus_message_bytes_needed(blob.to_glib_none().0, blob_len, &mut error);
            if error.is_null() {
                Ok(ret)
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "locked")]
    pub fn connect_locked_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_locked_trampoline<F: Fn(&DBusMessage) + 'static>(
            this: *mut ffi::GDBusMessage,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::locked".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_locked_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl Default for DBusMessage {
    fn default() -> Self {
        Self::new()
    }
}