// 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::{
    AsyncInitable, AsyncResult, Cancellable, Credentials, DBusAuthObserver, DBusCallFlags,
    DBusCapabilityFlags, DBusConnectionFlags, DBusMessage, DBusSendMessageFlags, IOStream,
    Initable,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem, mem::transmute, pin::Pin, ptr};

glib::wrapper! {
    /// The [`DBusConnection`][crate::DBusConnection] type is used for D-Bus connections to remote
    /// peers such as a message buses. It is a low-level API that offers a
    /// lot of flexibility. For instance, it lets you establish a connection
    /// over any transport that can by represented as a [`IOStream`][crate::IOStream].
    ///
    /// This class is rarely used directly in D-Bus clients. If you are writing
    /// a D-Bus client, it is often easier to use the `g_bus_own_name()`,
    /// `g_bus_watch_name()` or [`DBusProxy::for_bus()`][crate::DBusProxy::for_bus()] APIs.
    ///
    /// As an exception to the usual GLib rule that a particular object must not
    /// be used by two threads at the same time, [`DBusConnection`][crate::DBusConnection]'s methods may be
    /// called from any thread. This is so that [`bus_get()`][crate::bus_get()] and [`bus_get_sync()`][crate::bus_get_sync()]
    /// can safely return the same [`DBusConnection`][crate::DBusConnection] when called from any thread.
    ///
    /// Most of the ways to obtain a [`DBusConnection`][crate::DBusConnection] automatically initialize it
    /// (i.e. connect to D-Bus): for instance, [`new()`][Self::new()] and
    /// [`bus_get()`][crate::bus_get()], and the synchronous versions of those methods, give you an
    /// initialized connection. Language bindings for GIO should use
    /// [`Initable::new()`][crate::Initable::new()] or [`AsyncInitable::new_async()`][crate::AsyncInitable::new_async()], which also initialize the
    /// connection.
    ///
    /// If you construct an uninitialized [`DBusConnection`][crate::DBusConnection], such as via
    /// [`glib::Object::new()`][crate::glib::Object::new()], you must initialize it via [`InitableExt::init()`][crate::prelude::InitableExt::init()] or
    /// [`AsyncInitableExt::init_async()`][crate::prelude::AsyncInitableExt::init_async()] before using its methods or properties.
    /// Calling methods or accessing properties on a [`DBusConnection`][crate::DBusConnection] that has not
    /// completed initialization successfully is considered to be invalid, and leads
    /// to undefined behaviour. In particular, if initialization fails with a
    /// [`glib::Error`][crate::glib::Error], the only valid thing you can do with that [`DBusConnection`][crate::DBusConnection] is to
    /// free it with `g_object_unref()`.
    ///
    /// ## An example D-Bus server # {`gdbus`-server}
    ///
    /// Here is an example for a D-Bus server:
    /// [gdbus-example-server.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-server.c)
    ///
    /// ## An example for exporting a subtree # {`gdbus`-subtree-server}
    ///
    /// Here is an example for exporting a subtree:
    /// [gdbus-example-subtree.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-subtree.c)
    ///
    /// ## An example for file descriptor passing # {`gdbus`-unix-fd-client}
    ///
    /// Here is an example for passing UNIX file descriptors:
    /// [gdbus-unix-fd-client.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-unix-fd-client.c)
    ///
    /// ## An example for exporting a GObject # {`gdbus`-export}
    ///
    /// Here is an example for exporting a [`glib::Object`][crate::glib::Object]:
    /// [gdbus-example-export.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-export.c)
    ///
    /// ## Properties
    ///
    ///
    /// #### `address`
    ///  A D-Bus address specifying potential endpoints that can be used
    /// when establishing the connection.
    ///
    /// Writeable | Construct Only
    ///
    ///
    /// #### `authentication-observer`
    ///  A [`DBusAuthObserver`][crate::DBusAuthObserver] object to assist in the authentication process or [`None`].
    ///
    /// Writeable | Construct Only
    ///
    ///
    /// #### `capabilities`
    ///  Flags from the [`DBusCapabilityFlags`][crate::DBusCapabilityFlags] enumeration
    /// representing connection features negotiated with the other peer.
    ///
    /// Readable
    ///
    ///
    /// #### `closed`
    ///  A boolean specifying whether the connection has been closed.
    ///
    /// Readable
    ///
    ///
    /// #### `exit-on-close`
    ///  A boolean specifying whether the process will be terminated (by
    /// calling `raise(SIGTERM)`) if the connection is closed by the
    /// remote peer.
    ///
    /// Note that [`DBusConnection`][crate::DBusConnection] objects returned by `g_bus_get_finish()`
    /// and [`bus_get_sync()`][crate::bus_get_sync()] will (usually) have this property set to [`true`].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `flags`
    ///  Flags from the [`DBusConnectionFlags`][crate::DBusConnectionFlags] enumeration.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `guid`
    ///  The GUID of the peer performing the role of server when
    /// authenticating.
    ///
    /// If you are constructing a [`DBusConnection`][crate::DBusConnection] and pass
    /// [`DBusConnectionFlags::AUTHENTICATION_SERVER`][crate::DBusConnectionFlags::AUTHENTICATION_SERVER] in the
    /// [`flags`][struct@crate::DBusConnection#flags] property then you **must** also set this
    /// property to a valid guid.
    ///
    /// If you are constructing a [`DBusConnection`][crate::DBusConnection] and pass
    /// [`DBusConnectionFlags::AUTHENTICATION_CLIENT`][crate::DBusConnectionFlags::AUTHENTICATION_CLIENT] in the
    /// [`flags`][struct@crate::DBusConnection#flags] property you will be able to read the GUID
    /// of the other peer here after the connection has been successfully
    /// initialized.
    ///
    /// Note that the
    /// [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html`addresses`)
    /// uses the term ‘UUID’ to refer to this, whereas GLib consistently uses the
    /// term ‘GUID’ for historical reasons.
    ///
    /// Despite its name, the format of [`guid`][struct@crate::DBusConnection#guid] does not follow
    /// [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122) or the Microsoft
    /// GUID format.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `stream`
    ///  The underlying [`IOStream`][crate::IOStream] used for I/O.
    ///
    /// If this is passed on construction and is a [`SocketConnection`][crate::SocketConnection],
    /// then the corresponding [`Socket`][crate::Socket] will be put into non-blocking mode.
    ///
    /// While the [`DBusConnection`][crate::DBusConnection] is active, it will interact with this
    /// stream from a worker thread, so it is not safe to interact with
    /// the stream directly.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `unique-name`
    ///  The unique name as assigned by the message bus or [`None`] if the
    /// connection is not open or not a message bus connection.
    ///
    /// Readable
    ///
    /// ## Signals
    ///
    ///
    /// #### `closed`
    ///  Emitted when the connection is closed.
    ///
    /// The cause of this event can be
    ///
    /// - If [`DBusConnection::close()`][crate::DBusConnection::close()] is called. In this case
    ///  `remote_peer_vanished` is set to [`false`] and `error` is [`None`].
    ///
    /// - If the remote peer closes the connection. In this case
    ///  `remote_peer_vanished` is set to [`true`] and `error` is set.
    ///
    /// - If the remote peer sends invalid or malformed data. In this
    ///  case `remote_peer_vanished` is set to [`false`] and `error` is set.
    ///
    /// Upon receiving this signal, you should give up your reference to
    /// `connection`. You are guaranteed that this signal is emitted only
    /// once.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`], [`AsyncInitableExt`][trait@crate::prelude::AsyncInitableExt], [`InitableExt`][trait@crate::prelude::InitableExt]
    #[doc(alias = "GDBusConnection")]
    pub struct DBusConnection(Object<ffi::GDBusConnection>) @implements AsyncInitable, Initable;

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

impl DBusConnection {
    /// Synchronously connects and sets up a D-Bus client connection for
    /// exchanging D-Bus messages with an endpoint specified by `address`
    /// which must be in the
    /// [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html`addresses`).
    ///
    /// This constructor can only be used to initiate client-side
    /// connections - use [`new_sync()`][Self::new_sync()] if you need to act
    /// as the server. In particular, `flags` cannot contain the
    /// [`DBusConnectionFlags::AUTHENTICATION_SERVER`][crate::DBusConnectionFlags::AUTHENTICATION_SERVER],
    /// [`DBusConnectionFlags::AUTHENTICATION_ALLOW_ANONYMOUS`][crate::DBusConnectionFlags::AUTHENTICATION_ALLOW_ANONYMOUS] or
    /// [`DBusConnectionFlags::AUTHENTICATION_REQUIRE_SAME_USER`][crate::DBusConnectionFlags::AUTHENTICATION_REQUIRE_SAME_USER] flags.
    ///
    /// This is a synchronous failable constructor. See
    /// [`for_address()`][Self::for_address()] for the asynchronous version.
    ///
    /// If `observer` is not [`None`] it may be used to control the
    /// authentication process.
    /// ## `address`
    /// a D-Bus address
    /// ## `flags`
    /// flags describing how to make the connection
    /// ## `observer`
    /// a [`DBusAuthObserver`][crate::DBusAuthObserver] or [`None`]
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    ///
    /// # Returns
    ///
    /// a [`DBusConnection`][crate::DBusConnection] or [`None`] if `error` is set.
    ///  Free with `g_object_unref()`.
    #[doc(alias = "g_dbus_connection_new_for_address_sync")]
    #[doc(alias = "new_for_address_sync")]
    pub fn for_address_sync(
        address: &str,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<DBusConnection, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_new_for_address_sync(
                address.to_glib_none().0,
                flags.into_glib(),
                observer.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Synchronously sets up a D-Bus connection for exchanging D-Bus messages
    /// with the end represented by `stream`.
    ///
    /// If `stream` is a [`SocketConnection`][crate::SocketConnection], then the corresponding [`Socket`][crate::Socket]
    /// will be put into non-blocking mode.
    ///
    /// The D-Bus connection will interact with `stream` from a worker thread.
    /// As a result, the caller should not interact with `stream` after this
    /// method has been called, except by calling `g_object_unref()` on it.
    ///
    /// If `observer` is not [`None`] it may be used to control the
    /// authentication process.
    ///
    /// This is a synchronous failable constructor. See
    /// [`new()`][Self::new()] for the asynchronous version.
    /// ## `stream`
    /// a [`IOStream`][crate::IOStream]
    /// ## `guid`
    /// the GUID to use if authenticating as a server or [`None`]
    /// ## `flags`
    /// flags describing how to make the connection
    /// ## `observer`
    /// a [`DBusAuthObserver`][crate::DBusAuthObserver] or [`None`]
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    ///
    /// # Returns
    ///
    /// a [`DBusConnection`][crate::DBusConnection] or [`None`] if `error` is set.
    ///  Free with `g_object_unref()`.
    #[doc(alias = "g_dbus_connection_new_sync")]
    pub fn new_sync(
        stream: &impl IsA<IOStream>,
        guid: Option<&str>,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<DBusConnection, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_new_sync(
                stream.as_ref().to_glib_none().0,
                guid.to_glib_none().0,
                flags.into_glib(),
                observer.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously invokes the `method_name` method on the
    /// `interface_name` D-Bus interface on the remote object at
    /// `object_path` owned by `bus_name`.
    ///
    /// If `self` is closed then the operation will fail with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. If `cancellable` is canceled, the operation will
    /// fail with [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled]. If `parameters` contains a value
    /// not compatible with the D-Bus protocol, the operation fails with
    /// [`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument].
    ///
    /// If `reply_type` is non-[`None`] then the reply will be checked for having this type and an
    /// error will be raised if it does not match. Said another way, if you give a `reply_type`
    /// then any non-[`None`] return value will be of this type. Unless it’s
    /// `G_VARIANT_TYPE_UNIT`, the `reply_type` will be a tuple containing one or more
    /// values.
    ///
    /// If the `parameters` [`glib::Variant`][struct@crate::glib::Variant] is floating, it is consumed. This allows
    /// convenient 'inline' use of [`glib::Variant::new()`][crate::glib::Variant::new()], e.g.:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///  g_dbus_connection_call (connection,
    ///                          "org.freedesktop.StringThings",
    ///                          "/org/freedesktop/StringThings",
    ///                          "org.freedesktop.StringThings",
    ///                          "TwoStrings",
    ///                          g_variant_new ("(ss)",
    ///                                         "Thing One",
    ///                                         "Thing Two"),
    ///                          NULL,
    ///                          G_DBUS_CALL_FLAGS_NONE,
    ///                          -1,
    ///                          NULL,
    ///                          (GAsyncReadyCallback) two_strings_done,
    ///                          NULL);
    /// ```
    ///
    /// This is an asynchronous method. When the operation is finished,
    /// `callback` will be invoked in the
    /// [thread-default main context][g-main-context-push-thread-default]
    /// of the thread you are calling this method from. You can then call
    /// `g_dbus_connection_call_finish()` to get the result of the operation.
    /// See [`call_sync()`][Self::call_sync()] for the synchronous version of this
    /// function.
    ///
    /// If `callback` is [`None`] then the D-Bus method call message will be sent with
    /// the [`DBusMessageFlags::NO_REPLY_EXPECTED`][crate::DBusMessageFlags::NO_REPLY_EXPECTED] flag set.
    /// ## `bus_name`
    /// a unique or well-known bus name or [`None`] if
    ///  `self` is not a message bus connection
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to invoke method on
    /// ## `method_name`
    /// the name of the method to invoke
    /// ## `parameters`
    /// a [`glib::Variant`][struct@crate::glib::Variant] tuple with parameters for the method
    ///  or [`None`] if not passing parameters
    /// ## `reply_type`
    /// the expected type of the reply (which will be a
    ///  tuple), or [`None`]
    /// ## `flags`
    /// flags from the [`DBusCallFlags`][crate::DBusCallFlags] enumeration
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///  timeout or `G_MAXINT` for no timeout
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request
    ///  is satisfied or [`None`] if you don't care about the result of the
    ///  method invocation
    #[doc(alias = "g_dbus_connection_call")]
    pub fn call<P: FnOnce(Result<glib::Variant, glib::Error>) + 'static>(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn call_trampoline<
            P: FnOnce(Result<glib::Variant, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_call_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = call_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_call(
                self.to_glib_none().0,
                bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                method_name.to_glib_none().0,
                parameters.to_glib_none().0,
                reply_type.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn call_future(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<glib::Variant, glib::Error>> + 'static>>
    {
        let bus_name = bus_name.map(ToOwned::to_owned);
        let object_path = String::from(object_path);
        let interface_name = String::from(interface_name);
        let method_name = String::from(method_name);
        let parameters = parameters.map(ToOwned::to_owned);
        let reply_type = reply_type.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.call(
                    bus_name.as_ref().map(::std::borrow::Borrow::borrow),
                    &object_path,
                    &interface_name,
                    &method_name,
                    parameters.as_ref().map(::std::borrow::Borrow::borrow),
                    reply_type.as_ref().map(::std::borrow::Borrow::borrow),
                    flags,
                    timeout_msec,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Synchronously invokes the `method_name` method on the
    /// `interface_name` D-Bus interface on the remote object at
    /// `object_path` owned by `bus_name`.
    ///
    /// If `self` is closed then the operation will fail with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. If `cancellable` is canceled, the
    /// operation will fail with [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled]. If `parameters`
    /// contains a value not compatible with the D-Bus protocol, the operation
    /// fails with [`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument].
    ///
    /// If `reply_type` is non-[`None`] then the reply will be checked for having
    /// this type and an error will be raised if it does not match. Said
    /// another way, if you give a `reply_type` then any non-[`None`] return
    /// value will be of this type.
    ///
    /// If the `parameters` [`glib::Variant`][struct@crate::glib::Variant] is floating, it is consumed.
    /// This allows convenient 'inline' use of [`glib::Variant::new()`][crate::glib::Variant::new()], e.g.:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///  g_dbus_connection_call_sync (connection,
    ///                               "org.freedesktop.StringThings",
    ///                               "/org/freedesktop/StringThings",
    ///                               "org.freedesktop.StringThings",
    ///                               "TwoStrings",
    ///                               g_variant_new ("(ss)",
    ///                                              "Thing One",
    ///                                              "Thing Two"),
    ///                               NULL,
    ///                               G_DBUS_CALL_FLAGS_NONE,
    ///                               -1,
    ///                               NULL,
    ///                               &error);
    /// ```
    ///
    /// The calling thread is blocked until a reply is received. See
    /// [`call()`][Self::call()] for the asynchronous version of
    /// this method.
    /// ## `bus_name`
    /// a unique or well-known bus name or [`None`] if
    ///  `self` is not a message bus connection
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to invoke method on
    /// ## `method_name`
    /// the name of the method to invoke
    /// ## `parameters`
    /// a [`glib::Variant`][struct@crate::glib::Variant] tuple with parameters for the method
    ///  or [`None`] if not passing parameters
    /// ## `reply_type`
    /// the expected type of the reply, or [`None`]
    /// ## `flags`
    /// flags from the [`DBusCallFlags`][crate::DBusCallFlags] enumeration
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///  timeout or `G_MAXINT` for no timeout
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    ///
    /// # Returns
    ///
    /// [`None`] if `error` is set. Otherwise a non-floating
    ///  [`glib::Variant`][struct@crate::glib::Variant] tuple with return values. Free with `g_variant_unref()`.
    #[doc(alias = "g_dbus_connection_call_sync")]
    pub fn call_sync(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<glib::Variant, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_call_sync(
                self.to_glib_none().0,
                bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                method_name.to_glib_none().0,
                parameters.to_glib_none().0,
                reply_type.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Like [`call()`][Self::call()] but also takes a [`UnixFDList`][crate::UnixFDList] object.
    ///
    /// The file descriptors normally correspond to `G_VARIANT_TYPE_HANDLE`
    /// values in the body of the message. For example, if a message contains
    /// two file descriptors, `fd_list` would have length 2, and
    /// `g_variant_new_handle (0)` and `g_variant_new_handle (1)` would appear
    /// somewhere in the body of the message (not necessarily in that order!)
    /// to represent the file descriptors at indexes 0 and 1 respectively.
    ///
    /// 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 in this way by a
    /// value of type `G_VARIANT_TYPE_HANDLE` in the body of the message.
    ///
    /// This method is only available on UNIX.
    /// ## `bus_name`
    /// a unique or well-known bus name or [`None`] if
    ///  `self` is not a message bus connection
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to invoke method on
    /// ## `method_name`
    /// the name of the method to invoke
    /// ## `parameters`
    /// a [`glib::Variant`][struct@crate::glib::Variant] tuple with parameters for the method
    ///  or [`None`] if not passing parameters
    /// ## `reply_type`
    /// the expected type of the reply, or [`None`]
    /// ## `flags`
    /// flags from the [`DBusCallFlags`][crate::DBusCallFlags] enumeration
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///  timeout or `G_MAXINT` for no timeout
    /// ## `fd_list`
    /// a [`UnixFDList`][crate::UnixFDList] or [`None`]
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is
    ///  satisfied or [`None`] if you don't * care about the result of the
    ///  method invocation
    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    #[doc(alias = "g_dbus_connection_call_with_unix_fd_list")]
    pub fn call_with_unix_fd_list<
        P: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
    >(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        fd_list: Option<&impl IsA<UnixFDList>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn call_with_unix_fd_list_trampoline<
            P: FnOnce(Result<(glib::Variant, UnixFDList), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let mut out_fd_list = ptr::null_mut();
            let ret = ffi::g_dbus_connection_call_with_unix_fd_list_finish(
                _source_object as *mut _,
                &mut out_fd_list,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok((from_glib_full(ret), from_glib_full(out_fd_list)))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = call_with_unix_fd_list_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_call_with_unix_fd_list(
                self.to_glib_none().0,
                bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                method_name.to_glib_none().0,
                parameters.to_glib_none().0,
                reply_type.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                fd_list.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    pub fn call_with_unix_fd_list_future(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        fd_list: Option<&(impl IsA<UnixFDList> + Clone + 'static)>,
    ) -> Pin<
        Box_<
            dyn std::future::Future<Output = Result<(glib::Variant, UnixFDList), glib::Error>>
                + 'static,
        >,
    > {
        let bus_name = bus_name.map(ToOwned::to_owned);
        let object_path = String::from(object_path);
        let interface_name = String::from(interface_name);
        let method_name = String::from(method_name);
        let parameters = parameters.map(ToOwned::to_owned);
        let reply_type = reply_type.map(ToOwned::to_owned);
        let fd_list = fd_list.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.call_with_unix_fd_list(
                    bus_name.as_ref().map(::std::borrow::Borrow::borrow),
                    &object_path,
                    &interface_name,
                    &method_name,
                    parameters.as_ref().map(::std::borrow::Borrow::borrow),
                    reply_type.as_ref().map(::std::borrow::Borrow::borrow),
                    flags,
                    timeout_msec,
                    fd_list.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Like [`call_sync()`][Self::call_sync()] but also takes and returns [`UnixFDList`][crate::UnixFDList] objects.
    /// See [`call_with_unix_fd_list()`][Self::call_with_unix_fd_list()] and
    /// `g_dbus_connection_call_with_unix_fd_list_finish()` for more details.
    ///
    /// This method is only available on UNIX.
    /// ## `bus_name`
    /// a unique or well-known bus name or [`None`]
    ///  if `self` is not a message bus connection
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to invoke method on
    /// ## `method_name`
    /// the name of the method to invoke
    /// ## `parameters`
    /// a [`glib::Variant`][struct@crate::glib::Variant] tuple with parameters for
    ///  the method or [`None`] if not passing parameters
    /// ## `reply_type`
    /// the expected type of the reply, or [`None`]
    /// ## `flags`
    /// flags from the [`DBusCallFlags`][crate::DBusCallFlags] enumeration
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///  timeout or `G_MAXINT` for no timeout
    /// ## `fd_list`
    /// a [`UnixFDList`][crate::UnixFDList] or [`None`]
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    ///
    /// # Returns
    ///
    /// [`None`] if `error` is set. Otherwise a non-floating
    ///  [`glib::Variant`][struct@crate::glib::Variant] tuple with return values. Free with `g_variant_unref()`.
    ///
    /// ## `out_fd_list`
    /// return location for a [`UnixFDList`][crate::UnixFDList] or [`None`]
    #[cfg(unix)]
    #[cfg_attr(docsrs, doc(cfg(unix)))]
    #[doc(alias = "g_dbus_connection_call_with_unix_fd_list_sync")]
    pub fn call_with_unix_fd_list_sync(
        &self,
        bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        method_name: &str,
        parameters: Option<&glib::Variant>,
        reply_type: Option<&glib::VariantTy>,
        flags: DBusCallFlags,
        timeout_msec: i32,
        fd_list: Option<&impl IsA<UnixFDList>>,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(glib::Variant, UnixFDList), glib::Error> {
        unsafe {
            let mut out_fd_list = ptr::null_mut();
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_call_with_unix_fd_list_sync(
                self.to_glib_none().0,
                bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                method_name.to_glib_none().0,
                parameters.to_glib_none().0,
                reply_type.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                fd_list.map(|p| p.as_ref()).to_glib_none().0,
                &mut out_fd_list,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok((from_glib_full(ret), from_glib_full(out_fd_list)))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Closes `self`. Note that this never causes the process to
    /// exit (this might only happen if the other end of a shared message
    /// bus connection disconnects, see [`exit-on-close`][struct@crate::DBusConnection#exit-on-close]).
    ///
    /// Once the connection is closed, operations such as sending a message
    /// will return with the error [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. Closing a connection
    /// will not automatically flush the connection so queued messages may
    /// be lost. Use [`flush()`][Self::flush()] if you need such guarantees.
    ///
    /// If `self` is already closed, this method fails with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed].
    ///
    /// When `self` has been closed, the [`closed`][struct@crate::DBusConnection#closed]
    /// signal is emitted in the
    /// [thread-default main context][g-main-context-push-thread-default]
    /// of the thread that `self` was constructed in.
    ///
    /// This is an asynchronous method. When the operation is finished,
    /// `callback` will be invoked in the
    /// [thread-default main context][g-main-context-push-thread-default]
    /// of the thread you are calling this method from. You can
    /// then call `g_dbus_connection_close_finish()` to get the result of the
    /// operation. See [`close_sync()`][Self::close_sync()] for the synchronous
    /// version.
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is
    ///  satisfied or [`None`] if you don't care about the result
    #[doc(alias = "g_dbus_connection_close")]
    pub fn close<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn close_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let _ = ffi::g_dbus_connection_close_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = close_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_close(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn close_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.close(Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Synchronously closes `self`. The calling thread is blocked
    /// until this is done. See [`close()`][Self::close()] for the
    /// asynchronous version of this method and more details about what it
    /// does.
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the operation succeeded, [`false`] if `error` is set
    #[doc(alias = "g_dbus_connection_close_sync")]
    pub fn close_sync(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::g_dbus_connection_close_sync(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).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))
            }
        }
    }

    /// Emits a signal.
    ///
    /// If the parameters GVariant is floating, it is consumed.
    ///
    /// This can only fail if `parameters` is not compatible with the D-Bus protocol
    /// ([`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument]), or if `self` has been closed
    /// ([`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]).
    /// ## `destination_bus_name`
    /// the unique bus name for the destination
    ///  for the signal or [`None`] to emit to all listeners
    /// ## `object_path`
    /// path of remote object
    /// ## `interface_name`
    /// D-Bus interface to emit a signal on
    /// ## `signal_name`
    /// the name of the signal to emit
    /// ## `parameters`
    /// a [`glib::Variant`][struct@crate::glib::Variant] tuple with parameters for the signal
    ///  or [`None`] if not passing parameters
    ///
    /// # Returns
    ///
    /// [`true`] unless `error` is set
    #[doc(alias = "g_dbus_connection_emit_signal")]
    pub fn emit_signal(
        &self,
        destination_bus_name: Option<&str>,
        object_path: &str,
        interface_name: &str,
        signal_name: &str,
        parameters: Option<&glib::Variant>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::g_dbus_connection_emit_signal(
                self.to_glib_none().0,
                destination_bus_name.to_glib_none().0,
                object_path.to_glib_none().0,
                interface_name.to_glib_none().0,
                signal_name.to_glib_none().0,
                parameters.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))
            }
        }
    }

    /// Asynchronously flushes `self`, that is, writes all queued
    /// outgoing message to the transport and then flushes the transport
    /// (using [`OutputStreamExt::flush_async()`][crate::prelude::OutputStreamExt::flush_async()]). This is useful in programs
    /// that wants to emit a D-Bus signal and then exit immediately. Without
    /// flushing the connection, there is no guaranteed that the message has
    /// been sent to the networking buffers in the OS kernel.
    ///
    /// This is an asynchronous method. When the operation is finished,
    /// `callback` will be invoked in the
    /// [thread-default main context][g-main-context-push-thread-default]
    /// of the thread you are calling this method from. You can
    /// then call `g_dbus_connection_flush_finish()` to get the result of the
    /// operation. See [`flush_sync()`][Self::flush_sync()] for the synchronous
    /// version.
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the
    ///  request is satisfied or [`None`] if you don't care about the result
    #[doc(alias = "g_dbus_connection_flush")]
    pub fn flush<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn flush_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let _ = ffi::g_dbus_connection_flush_finish(_source_object as *mut _, res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = flush_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_flush(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn flush_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.flush(Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Synchronously flushes `self`. The calling thread is blocked
    /// until this is done. See [`flush()`][Self::flush()] for the
    /// asynchronous version of this method and more details about what it
    /// does.
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if the operation succeeded, [`false`] if `error` is set
    #[doc(alias = "g_dbus_connection_flush_sync")]
    pub fn flush_sync(
        &self,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::g_dbus_connection_flush_sync(
                self.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).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))
            }
        }
    }

    /// Gets the capabilities negotiated with the remote peer
    ///
    /// # Returns
    ///
    /// zero or more flags from the [`DBusCapabilityFlags`][crate::DBusCapabilityFlags] enumeration
    #[doc(alias = "g_dbus_connection_get_capabilities")]
    #[doc(alias = "get_capabilities")]
    pub fn capabilities(&self) -> DBusCapabilityFlags {
        unsafe {
            from_glib(ffi::g_dbus_connection_get_capabilities(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets whether the process is terminated when `self` is
    /// closed by the remote peer. See
    /// [`exit-on-close`][struct@crate::DBusConnection#exit-on-close] for more details.
    ///
    /// # Returns
    ///
    /// whether the process is terminated when `self` is
    ///  closed by the remote peer
    #[doc(alias = "g_dbus_connection_get_exit_on_close")]
    #[doc(alias = "get_exit_on_close")]
    pub fn exits_on_close(&self) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_connection_get_exit_on_close(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the flags used to construct this connection
    ///
    /// # Returns
    ///
    /// zero or more flags from the [`DBusConnectionFlags`][crate::DBusConnectionFlags] enumeration
    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "g_dbus_connection_get_flags")]
    #[doc(alias = "get_flags")]
    pub fn flags(&self) -> DBusConnectionFlags {
        unsafe { from_glib(ffi::g_dbus_connection_get_flags(self.to_glib_none().0)) }
    }

    /// The GUID of the peer performing the role of server when
    /// authenticating. See [`guid`][struct@crate::DBusConnection#guid] for more details.
    ///
    /// # Returns
    ///
    /// The GUID. Do not free this string, it is owned by
    ///  `self`.
    #[doc(alias = "g_dbus_connection_get_guid")]
    #[doc(alias = "get_guid")]
    pub fn guid(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::g_dbus_connection_get_guid(self.to_glib_none().0)) }
    }

    /// Retrieves the last serial number assigned to a [`DBusMessage`][crate::DBusMessage] on
    /// the current thread. This includes messages sent via both low-level
    /// API such as [`send_message()`][Self::send_message()] as well as
    /// high-level API such as [`emit_signal()`][Self::emit_signal()],
    /// [`call()`][Self::call()] or [`DBusProxyExt::call()`][crate::prelude::DBusProxyExt::call()].
    ///
    /// # Returns
    ///
    /// the last used serial or zero when no message has been sent
    ///  within the current thread
    #[doc(alias = "g_dbus_connection_get_last_serial")]
    #[doc(alias = "get_last_serial")]
    pub fn last_serial(&self) -> u32 {
        unsafe { ffi::g_dbus_connection_get_last_serial(self.to_glib_none().0) }
    }

    /// Gets the credentials of the authenticated peer. This will always
    /// return [`None`] unless `self` acted as a server
    /// (e.g. [`DBusConnectionFlags::AUTHENTICATION_SERVER`][crate::DBusConnectionFlags::AUTHENTICATION_SERVER] was passed)
    /// when set up and the client passed credentials as part of the
    /// authentication process.
    ///
    /// In a message bus setup, the message bus is always the server and
    /// each application is a client. So this method will always return
    /// [`None`] for message bus clients.
    ///
    /// # Returns
    ///
    /// a [`Credentials`][crate::Credentials] or [`None`] if not
    ///  available. Do not free this object, it is owned by `self`.
    #[doc(alias = "g_dbus_connection_get_peer_credentials")]
    #[doc(alias = "get_peer_credentials")]
    pub fn peer_credentials(&self) -> Option<Credentials> {
        unsafe {
            from_glib_none(ffi::g_dbus_connection_get_peer_credentials(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the underlying stream used for IO.
    ///
    /// While the [`DBusConnection`][crate::DBusConnection] is active, it will interact with this
    /// stream from a worker thread, so it is not safe to interact with
    /// the stream directly.
    ///
    /// # Returns
    ///
    /// the stream used for IO
    #[doc(alias = "g_dbus_connection_get_stream")]
    #[doc(alias = "get_stream")]
    pub fn stream(&self) -> IOStream {
        unsafe { from_glib_none(ffi::g_dbus_connection_get_stream(self.to_glib_none().0)) }
    }

    /// Gets the unique name of `self` as assigned by the message
    /// bus. This can also be used to figure out if `self` is a
    /// message bus connection.
    ///
    /// # Returns
    ///
    /// the unique name or [`None`] if `self` is not a message
    ///  bus connection. Do not free this string, it is owned by
    ///  `self`.
    #[doc(alias = "g_dbus_connection_get_unique_name")]
    #[doc(alias = "get_unique_name")]
    pub fn unique_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_dbus_connection_get_unique_name(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets whether `self` is closed.
    ///
    /// # Returns
    ///
    /// [`true`] if the connection is closed, [`false`] otherwise
    #[doc(alias = "g_dbus_connection_is_closed")]
    pub fn is_closed(&self) -> bool {
        unsafe { from_glib(ffi::g_dbus_connection_is_closed(self.to_glib_none().0)) }
    }

    //#[doc(alias = "g_dbus_connection_register_object")]
    //pub fn register_object(&self, object_path: &str, interface_info: &DBusInterfaceInfo, vtable: /*Ignored*/Option<&DBusInterfaceVTable>, user_data: /*Unimplemented*/Option<Basic: Pointer>) -> Result<(), glib::Error> {
    //    unsafe { TODO: call ffi:g_dbus_connection_register_object() }
    //}

    /// Asynchronously sends `message` to the peer represented by `self`.
    ///
    /// Unless `flags` contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag, the serial number
    /// will be assigned by `self` and set on `message` via
    /// [`DBusMessage::set_serial()`][crate::DBusMessage::set_serial()]. If `out_serial` is not [`None`], then the
    /// serial number used will be written to this location prior to
    /// submitting the message to the underlying transport. While it has a `volatile`
    /// qualifier, this is a historical artifact and the argument passed to it should
    /// not be `volatile`.
    ///
    /// If `self` is closed then the operation will fail with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. If `message` is not well-formed,
    /// the operation fails with [`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument].
    ///
    /// See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
    /// for an example of how to use this low-level API to send and receive
    /// UNIX file descriptors.
    ///
    /// Note that `message` must be unlocked, unless `flags` contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag.
    /// ## `message`
    /// a [`DBusMessage`][crate::DBusMessage]
    /// ## `flags`
    /// flags affecting how the message is sent
    ///
    /// # Returns
    ///
    /// [`true`] if the message was well-formed and queued for
    ///  transmission, [`false`] if `error` is set
    ///
    /// ## `out_serial`
    /// return location for serial number assigned
    ///  to `message` when sending it or [`None`]
    #[doc(alias = "g_dbus_connection_send_message")]
    pub fn send_message(
        &self,
        message: &DBusMessage,
        flags: DBusSendMessageFlags,
    ) -> Result<u32, glib::Error> {
        unsafe {
            let mut out_serial = mem::MaybeUninit::uninit();
            let mut error = ptr::null_mut();
            let is_ok = ffi::g_dbus_connection_send_message(
                self.to_glib_none().0,
                message.to_glib_none().0,
                flags.into_glib(),
                out_serial.as_mut_ptr(),
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(out_serial.assume_init())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously sends `message` to the peer represented by `self`.
    ///
    /// Unless `flags` contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag, the serial number
    /// will be assigned by `self` and set on `message` via
    /// [`DBusMessage::set_serial()`][crate::DBusMessage::set_serial()]. If `out_serial` is not [`None`], then the
    /// serial number used will be written to this location prior to
    /// submitting the message to the underlying transport. While it has a `volatile`
    /// qualifier, this is a historical artifact and the argument passed to it should
    /// not be `volatile`.
    ///
    /// If `self` is closed then the operation will fail with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. If `cancellable` is canceled, the operation will
    /// fail with [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled]. If `message` is not well-formed,
    /// the operation fails with [`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument].
    ///
    /// This is an asynchronous method. When the operation is finished, `callback`
    /// will be invoked in the
    /// [thread-default main context][g-main-context-push-thread-default]
    /// of the thread you are calling this method from. You can then call
    /// `g_dbus_connection_send_message_with_reply_finish()` to get the result of the operation.
    /// See [`send_message_with_reply_sync()`][Self::send_message_with_reply_sync()] for the synchronous version.
    ///
    /// Note that `message` must be unlocked, unless `flags` contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag.
    ///
    /// See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
    /// for an example of how to use this low-level API to send and receive
    /// UNIX file descriptors.
    /// ## `message`
    /// a [`DBusMessage`][crate::DBusMessage]
    /// ## `flags`
    /// flags affecting how the message is sent
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///  timeout or `G_MAXINT` for no timeout
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request
    ///  is satisfied or [`None`] if you don't care about the result
    ///
    /// # Returns
    ///
    ///
    /// ## `out_serial`
    /// return location for serial number assigned
    ///  to `message` when sending it or [`None`]
    #[doc(alias = "g_dbus_connection_send_message_with_reply")]
    pub fn send_message_with_reply<P: FnOnce(Result<DBusMessage, glib::Error>) + 'static>(
        &self,
        message: &DBusMessage,
        flags: DBusSendMessageFlags,
        timeout_msec: i32,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) -> u32 {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn send_message_with_reply_trampoline<
            P: FnOnce(Result<DBusMessage, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_send_message_with_reply_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = send_message_with_reply_trampoline::<P>;
        unsafe {
            let mut out_serial = mem::MaybeUninit::uninit();
            ffi::g_dbus_connection_send_message_with_reply(
                self.to_glib_none().0,
                message.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                out_serial.as_mut_ptr(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
            out_serial.assume_init()
        }
    }

    pub fn send_message_with_reply_future(
        &self,
        message: &DBusMessage,
        flags: DBusSendMessageFlags,
        timeout_msec: i32,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusMessage, glib::Error>> + 'static>>
    {
        let message = message.clone();
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.send_message_with_reply(
                    &message,
                    flags,
                    timeout_msec,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Synchronously sends `message` to the peer represented by `self`
    /// and blocks the calling thread until a reply is received or the
    /// timeout is reached. See [`send_message_with_reply()`][Self::send_message_with_reply()]
    /// for the asynchronous version of this method.
    ///
    /// Unless `flags` contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag, the serial number
    /// will be assigned by `self` and set on `message` via
    /// [`DBusMessage::set_serial()`][crate::DBusMessage::set_serial()]. If `out_serial` is not [`None`], then the
    /// serial number used will be written to this location prior to
    /// submitting the message to the underlying transport. While it has a `volatile`
    /// qualifier, this is a historical artifact and the argument passed to it should
    /// not be `volatile`.
    ///
    /// If `self` is closed then the operation will fail with
    /// [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed]. If `cancellable` is canceled, the operation will
    /// fail with [`IOErrorEnum::Cancelled`][crate::IOErrorEnum::Cancelled]. If `message` is not well-formed,
    /// the operation fails with [`IOErrorEnum::InvalidArgument`][crate::IOErrorEnum::InvalidArgument].
    ///
    /// Note that `error` is only set if a local in-process error
    /// occurred. That is to say that the returned [`DBusMessage`][crate::DBusMessage] object may
    /// be of type [`DBusMessageType::Error`][crate::DBusMessageType::Error]. Use
    /// [`DBusMessage::to_gerror()`][crate::DBusMessage::to_gerror()] to transcode this to a [`glib::Error`][crate::glib::Error].
    ///
    /// See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
    /// for an example of how to use this low-level API to send and receive
    /// UNIX file descriptors.
    ///
    /// Note that `message` must be unlocked, unless `flags` contain the
    /// [`DBusSendMessageFlags::PRESERVE_SERIAL`][crate::DBusSendMessageFlags::PRESERVE_SERIAL] flag.
    /// ## `message`
    /// a [`DBusMessage`][crate::DBusMessage]
    /// ## `flags`
    /// flags affecting how the message is sent.
    /// ## `timeout_msec`
    /// the timeout in milliseconds, -1 to use the default
    ///  timeout or `G_MAXINT` for no timeout
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    ///
    /// # Returns
    ///
    /// a locked [`DBusMessage`][crate::DBusMessage] that is the reply
    ///  to `message` or [`None`] if `error` is set
    ///
    /// ## `out_serial`
    /// return location for serial number
    ///  assigned to `message` when sending it or [`None`]
    #[doc(alias = "g_dbus_connection_send_message_with_reply_sync")]
    pub fn send_message_with_reply_sync(
        &self,
        message: &DBusMessage,
        flags: DBusSendMessageFlags,
        timeout_msec: i32,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(DBusMessage, u32), glib::Error> {
        unsafe {
            let mut out_serial = mem::MaybeUninit::uninit();
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_send_message_with_reply_sync(
                self.to_glib_none().0,
                message.to_glib_none().0,
                flags.into_glib(),
                timeout_msec,
                out_serial.as_mut_ptr(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok((from_glib_full(ret), out_serial.assume_init()))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets whether the process should be terminated when `self` is
    /// closed by the remote peer. See [`exit-on-close`][struct@crate::DBusConnection#exit-on-close] for
    /// more details.
    ///
    /// Note that this function should be used with care. Most modern UNIX
    /// desktops tie the notion of a user session with the session bus, and expect
    /// all of a user's applications to quit when their bus connection goes away.
    /// If you are setting `exit_on_close` to [`false`] for the shared session
    /// bus connection, you should make sure that your application exits
    /// when the user session ends.
    /// ## `exit_on_close`
    /// whether the process should be terminated
    ///  when `self` is closed by the remote peer
    #[doc(alias = "g_dbus_connection_set_exit_on_close")]
    pub fn set_exit_on_close(&self, exit_on_close: bool) {
        unsafe {
            ffi::g_dbus_connection_set_exit_on_close(
                self.to_glib_none().0,
                exit_on_close.into_glib(),
            );
        }
    }

    /// If `self` was created with
    /// [`DBusConnectionFlags::DELAY_MESSAGE_PROCESSING`][crate::DBusConnectionFlags::DELAY_MESSAGE_PROCESSING], this method
    /// starts processing messages. Does nothing on if `self` wasn't
    /// created with this flag or if the method has already been called.
    #[doc(alias = "g_dbus_connection_start_message_processing")]
    pub fn start_message_processing(&self) {
        unsafe {
            ffi::g_dbus_connection_start_message_processing(self.to_glib_none().0);
        }
    }

    /// Flags from the [`DBusConnectionFlags`][crate::DBusConnectionFlags] enumeration.
    pub fn get_property_flags(&self) -> DBusConnectionFlags {
        ObjectExt::property(self, "flags")
    }

    /// Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
    /// with the end represented by `stream`.
    ///
    /// If `stream` is a [`SocketConnection`][crate::SocketConnection], then the corresponding [`Socket`][crate::Socket]
    /// will be put into non-blocking mode.
    ///
    /// The D-Bus connection will interact with `stream` from a worker thread.
    /// As a result, the caller should not interact with `stream` after this
    /// method has been called, except by calling `g_object_unref()` on it.
    ///
    /// If `observer` is not [`None`] it may be used to control the
    /// authentication process.
    ///
    /// When the operation is finished, `callback` will be invoked. You can
    /// then call `g_dbus_connection_new_finish()` to get the result of the
    /// operation.
    ///
    /// This is an asynchronous failable constructor. See
    /// [`new_sync()`][Self::new_sync()] for the synchronous
    /// version.
    /// ## `stream`
    /// a [`IOStream`][crate::IOStream]
    /// ## `guid`
    /// the GUID to use if authenticating as a server or [`None`]
    /// ## `flags`
    /// flags describing how to make the connection
    /// ## `observer`
    /// a [`DBusAuthObserver`][crate::DBusAuthObserver] or [`None`]
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[doc(alias = "g_dbus_connection_new")]
    pub fn new<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
        stream: &impl IsA<IOStream>,
        guid: Option<&str>,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn new_trampoline<
            P: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_new_finish(res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = new_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_new(
                stream.as_ref().to_glib_none().0,
                guid.to_glib_none().0,
                flags.into_glib(),
                observer.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn new_future(
        stream: &(impl IsA<IOStream> + Clone + 'static),
        guid: Option<&str>,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusConnection, glib::Error>> + 'static>>
    {
        let stream = stream.clone();
        let guid = guid.map(ToOwned::to_owned);
        let observer = observer.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            &(),
            move |_obj, cancellable, send| {
                Self::new(
                    &stream,
                    guid.as_ref().map(::std::borrow::Borrow::borrow),
                    flags,
                    observer.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Asynchronously connects and sets up a D-Bus client connection for
    /// exchanging D-Bus messages with an endpoint specified by `address`
    /// which must be in the
    /// [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html`addresses`).
    ///
    /// This constructor can only be used to initiate client-side
    /// connections - use [`new()`][Self::new()] if you need to act as the
    /// server. In particular, `flags` cannot contain the
    /// [`DBusConnectionFlags::AUTHENTICATION_SERVER`][crate::DBusConnectionFlags::AUTHENTICATION_SERVER],
    /// [`DBusConnectionFlags::AUTHENTICATION_ALLOW_ANONYMOUS`][crate::DBusConnectionFlags::AUTHENTICATION_ALLOW_ANONYMOUS] or
    /// [`DBusConnectionFlags::AUTHENTICATION_REQUIRE_SAME_USER`][crate::DBusConnectionFlags::AUTHENTICATION_REQUIRE_SAME_USER] flags.
    ///
    /// When the operation is finished, `callback` will be invoked. You can
    /// then call `g_dbus_connection_new_for_address_finish()` to get the result of
    /// the operation.
    ///
    /// If `observer` is not [`None`] it may be used to control the
    /// authentication process.
    ///
    /// This is an asynchronous failable constructor. See
    /// [`for_address_sync()`][Self::for_address_sync()] for the synchronous
    /// version.
    /// ## `address`
    /// a D-Bus address
    /// ## `flags`
    /// flags describing how to make the connection
    /// ## `observer`
    /// a [`DBusAuthObserver`][crate::DBusAuthObserver] or [`None`]
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable] or [`None`]
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is satisfied
    #[doc(alias = "g_dbus_connection_new_for_address")]
    #[doc(alias = "new_for_address")]
    pub fn for_address<P: FnOnce(Result<DBusConnection, glib::Error>) + 'static>(
        address: &str,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn for_address_trampoline<
            P: FnOnce(Result<DBusConnection, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = ffi::g_dbus_connection_new_for_address_finish(res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = for_address_trampoline::<P>;
        unsafe {
            ffi::g_dbus_connection_new_for_address(
                address.to_glib_none().0,
                flags.into_glib(),
                observer.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn for_address_future(
        address: &str,
        flags: DBusConnectionFlags,
        observer: Option<&DBusAuthObserver>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<DBusConnection, glib::Error>> + 'static>>
    {
        let address = String::from(address);
        let observer = observer.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            &(),
            move |_obj, cancellable, send| {
                Self::for_address(
                    &address,
                    flags,
                    observer.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Emitted when the connection is closed.
    ///
    /// The cause of this event can be
    ///
    /// - If [`close()`][Self::close()] is called. In this case
    ///  `remote_peer_vanished` is set to [`false`] and `error` is [`None`].
    ///
    /// - If the remote peer closes the connection. In this case
    ///  `remote_peer_vanished` is set to [`true`] and `error` is set.
    ///
    /// - If the remote peer sends invalid or malformed data. In this
    ///  case `remote_peer_vanished` is set to [`false`] and `error` is set.
    ///
    /// Upon receiving this signal, you should give up your reference to
    /// `connection`. You are guaranteed that this signal is emitted only
    /// once.
    /// ## `remote_peer_vanished`
    /// [`true`] if `connection` is closed because the
    ///  remote peer closed its end of the connection
    /// ## `error`
    /// a [`glib::Error`][crate::glib::Error] with more details about the event or [`None`]
    #[doc(alias = "closed")]
    pub fn connect_closed<F: Fn(&Self, bool, Option<&glib::Error>) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn closed_trampoline<
            F: Fn(&DBusConnection, bool, Option<&glib::Error>) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            remote_peer_vanished: glib::ffi::gboolean,
            error: *mut glib::ffi::GError,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                from_glib(remote_peer_vanished),
                Option::<glib::Error>::from_glib_borrow(error)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"closed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    closed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "capabilities")]
    pub fn connect_capabilities_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_capabilities_trampoline<
            F: Fn(&DBusConnection) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::capabilities\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_capabilities_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "closed")]
    pub fn connect_closed_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_closed_trampoline<
            F: Fn(&DBusConnection) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::closed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_closed_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "exit-on-close")]
    pub fn connect_exit_on_close_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_exit_on_close_trampoline<
            F: Fn(&DBusConnection) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::exit-on-close\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_exit_on_close_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "unique-name")]
    pub fn connect_unique_name_notify<F: Fn(&Self) + Send + Sync + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_unique_name_trampoline<
            F: Fn(&DBusConnection) + Send + Sync + 'static,
        >(
            this: *mut ffi::GDBusConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            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 _,
                b"notify::unique-name\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_unique_name_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

unsafe impl Send for DBusConnection {}
unsafe impl Sync for DBusConnection {}

impl fmt::Display for DBusConnection {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("DBusConnection")
    }
}