// 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

use gio_sys;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString;
use glib_sys;
use gobject_sys;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;
use std::pin::Pin;
use std::ptr;
use Cancellable;
use InetAddress;
#[cfg(any(feature = "v2_60", feature = "dox"))]
use ResolverNameLookupFlags;
use ResolverRecordType;
use SrvTarget;

glib_wrapper! {
    /// `Resolver` provides cancellable synchronous and asynchronous DNS
    /// resolution, for hostnames (`ResolverExt::lookup_by_address`,
    /// `ResolverExt::lookup_by_name` and their async variants) and SRV
    /// (service) records (`ResolverExt::lookup_service`).
    ///
    /// `NetworkAddress` and `NetworkService` provide wrappers around
    /// `Resolver` functionality that also implement `SocketConnectable`,
    /// making it easy to connect to a remote host/service.
    ///
    /// # Implements
    ///
    /// [`ResolverExt`](trait.ResolverExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html)
    pub struct Resolver(Object<gio_sys::GResolver, gio_sys::GResolverClass, ResolverClass>);

    match fn {
        get_type => || gio_sys::g_resolver_get_type(),
    }
}

impl Resolver {
    //pub fn free_addresses(addresses: /*Unimplemented*/&[&Fundamental: Pointer]) {
    //    unsafe { TODO: call gio_sys:g_resolver_free_addresses() }
    //}

    //pub fn free_targets(targets: /*Unimplemented*/&[&Fundamental: Pointer]) {
    //    unsafe { TODO: call gio_sys:g_resolver_free_targets() }
    //}

    /// Gets the default `Resolver`. You should unref it when you are done
    /// with it. `Resolver` may use its reference count as a hint about how
    /// many threads it should allocate for concurrent DNS resolutions.
    ///
    /// # Returns
    ///
    /// the default `Resolver`.
    pub fn get_default() -> Option<Resolver> {
        unsafe { from_glib_full(gio_sys::g_resolver_get_default()) }
    }
}

pub const NONE_RESOLVER: Option<&Resolver> = None;

/// Trait containing all `Resolver` methods.
///
/// # Implementors
///
/// [`Resolver`](struct.Resolver.html)
pub trait ResolverExt: 'static {
    /// Synchronously reverse-resolves `address` to determine its
    /// associated hostname.
    ///
    /// If the DNS resolution fails, `error` (if non-`None`) will be set to
    /// a value from `ResolverError`.
    ///
    /// If `cancellable` is non-`None`, it can be used to cancel the
    /// operation, in which case `error` (if non-`None`) will be set to
    /// `IOErrorEnum::Cancelled`.
    /// ## `address`
    /// the address to reverse-resolve
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    ///
    /// # Returns
    ///
    /// a hostname (either ASCII-only, or in ASCII-encoded
    ///  form), or `None` on error.
    fn lookup_by_address<P: IsA<InetAddress>, Q: IsA<Cancellable>>(
        &self,
        address: &P,
        cancellable: Option<&Q>,
    ) -> Result<GString, glib::Error>;

    /// Begins asynchronously reverse-resolving `address` to determine its
    /// associated hostname, and eventually calls `callback`, which must
    /// call `ResolverExt::lookup_by_address_finish` to get the final result.
    /// ## `address`
    /// the address to reverse-resolve
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    /// ## `callback`
    /// callback to call after resolution completes
    /// ## `user_data`
    /// data for `callback`
    fn lookup_by_address_async<
        P: IsA<InetAddress>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<GString, glib::Error>) + Send + 'static,
    >(
        &self,
        address: &P,
        cancellable: Option<&Q>,
        callback: R,
    );

    fn lookup_by_address_async_future<P: IsA<InetAddress> + Clone + 'static>(
        &self,
        address: &P,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<GString, glib::Error>> + 'static>>;

    /// Synchronously resolves `hostname` to determine its associated IP
    /// address(es). `hostname` may be an ASCII-only or UTF-8 hostname, or
    /// the textual form of an IP address (in which case this just becomes
    /// a wrapper around `InetAddress::new_from_string`).
    ///
    /// On success, `ResolverExt::lookup_by_name` will return a non-empty `glib::List` of
    /// `InetAddress`, sorted in order of preference and guaranteed to not
    /// contain duplicates. That is, if using the result to connect to
    /// `hostname`, you should attempt to connect to the first address
    /// first, then the second if the first fails, etc. If you are using
    /// the result to listen on a socket, it is appropriate to add each
    /// result using e.g. `SocketListenerExt::add_address`.
    ///
    /// If the DNS resolution fails, `error` (if non-`None`) will be set to a
    /// value from `ResolverError` and `None` will be returned.
    ///
    /// If `cancellable` is non-`None`, it can be used to cancel the
    /// operation, in which case `error` (if non-`None`) will be set to
    /// `IOErrorEnum::Cancelled`.
    ///
    /// If you are planning to connect to a socket on the resolved IP
    /// address, it may be easier to create a `NetworkAddress` and use its
    /// `SocketConnectable` interface.
    /// ## `hostname`
    /// the hostname to look up
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    ///
    /// # Returns
    ///
    /// a non-empty `glib::List`
    /// of `InetAddress`, or `None` on error. You
    /// must unref each of the addresses and free the list when you are
    /// done with it. (You can use `Resolver::free_addresses` to do this.)
    fn lookup_by_name<P: IsA<Cancellable>>(
        &self,
        hostname: &str,
        cancellable: Option<&P>,
    ) -> Result<Vec<InetAddress>, glib::Error>;

    /// Begins asynchronously resolving `hostname` to determine its
    /// associated IP address(es), and eventually calls `callback`, which
    /// must call `ResolverExt::lookup_by_name_finish` to get the result.
    /// See `ResolverExt::lookup_by_name` for more details.
    /// ## `hostname`
    /// the hostname to look up the address of
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    /// ## `callback`
    /// callback to call after resolution completes
    /// ## `user_data`
    /// data for `callback`
    fn lookup_by_name_async<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static,
    >(
        &self,
        hostname: &str,
        cancellable: Option<&P>,
        callback: Q,
    );

    fn lookup_by_name_async_future(
        &self,
        hostname: &str,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>;

    /// This differs from `ResolverExt::lookup_by_name` in that you can modify
    /// the lookup behavior with `flags`. For example this can be used to limit
    /// results with `ResolverNameLookupFlags::Ipv4Only`.
    ///
    /// Feature: `v2_60`
    ///
    /// ## `hostname`
    /// the hostname to look up
    /// ## `flags`
    /// extra `ResolverNameLookupFlags` for the lookup
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    ///
    /// # Returns
    ///
    /// a non-empty `glib::List`
    /// of `InetAddress`, or `None` on error. You
    /// must unref each of the addresses and free the list when you are
    /// done with it. (You can use `Resolver::free_addresses` to do this.)
    #[cfg(any(feature = "v2_60", feature = "dox"))]
    fn lookup_by_name_with_flags<P: IsA<Cancellable>>(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
        cancellable: Option<&P>,
    ) -> Result<Vec<InetAddress>, glib::Error>;

    /// Begins asynchronously resolving `hostname` to determine its
    /// associated IP address(es), and eventually calls `callback`, which
    /// must call `ResolverExt::lookup_by_name_with_flags_finish` to get the result.
    /// See `ResolverExt::lookup_by_name` for more details.
    ///
    /// Feature: `v2_60`
    ///
    /// ## `hostname`
    /// the hostname to look up the address of
    /// ## `flags`
    /// extra `ResolverNameLookupFlags` for the lookup
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    /// ## `callback`
    /// callback to call after resolution completes
    /// ## `user_data`
    /// data for `callback`
    #[cfg(any(feature = "v2_60", feature = "dox"))]
    fn lookup_by_name_with_flags_async<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static,
    >(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
        cancellable: Option<&P>,
        callback: Q,
    );

    #[cfg(any(feature = "v2_60", feature = "dox"))]
    fn lookup_by_name_with_flags_async_future(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>;

    /// Synchronously performs a DNS record lookup for the given `rrname` and returns
    /// a list of records as `glib::Variant` tuples. See `ResolverRecordType` for
    /// information on what the records contain for each `record_type`.
    ///
    /// If the DNS resolution fails, `error` (if non-`None`) will be set to
    /// a value from `ResolverError` and `None` will be returned.
    ///
    /// If `cancellable` is non-`None`, it can be used to cancel the
    /// operation, in which case `error` (if non-`None`) will be set to
    /// `IOErrorEnum::Cancelled`.
    /// ## `rrname`
    /// the DNS name to look up the record for
    /// ## `record_type`
    /// the type of DNS record to look up
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    ///
    /// # Returns
    ///
    /// a non-empty `glib::List` of
    /// `glib::Variant`, or `None` on error. You must free each of the records and the list
    /// when you are done with it. (You can use `glib::List::free_full` with
    /// `glib::Variant::unref` to do this.)
    fn lookup_records<P: IsA<Cancellable>>(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
        cancellable: Option<&P>,
    ) -> Result<Vec<glib::Variant>, glib::Error>;

    /// Begins asynchronously performing a DNS lookup for the given
    /// `rrname`, and eventually calls `callback`, which must call
    /// `ResolverExt::lookup_records_finish` to get the final result. See
    /// `ResolverExt::lookup_records` for more details.
    /// ## `rrname`
    /// the DNS name to look up the record for
    /// ## `record_type`
    /// the type of DNS record to look up
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    /// ## `callback`
    /// callback to call after resolution completes
    /// ## `user_data`
    /// data for `callback`
    fn lookup_records_async<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + Send + 'static,
    >(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
        cancellable: Option<&P>,
        callback: Q,
    );

    fn lookup_records_async_future(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
    ) -> Pin<
        Box_<dyn std::future::Future<Output = Result<Vec<glib::Variant>, glib::Error>> + 'static>,
    >;

    /// Synchronously performs a DNS SRV lookup for the given `service` and
    /// `protocol` in the given `domain` and returns an array of `SrvTarget`.
    /// `domain` may be an ASCII-only or UTF-8 hostname. Note also that the
    /// `service` and `protocol` arguments do not include the leading underscore
    /// that appears in the actual DNS entry.
    ///
    /// On success, `ResolverExt::lookup_service` will return a non-empty `glib::List` of
    /// `SrvTarget`, sorted in order of preference. (That is, you should
    /// attempt to connect to the first target first, then the second if
    /// the first fails, etc.)
    ///
    /// If the DNS resolution fails, `error` (if non-`None`) will be set to
    /// a value from `ResolverError` and `None` will be returned.
    ///
    /// If `cancellable` is non-`None`, it can be used to cancel the
    /// operation, in which case `error` (if non-`None`) will be set to
    /// `IOErrorEnum::Cancelled`.
    ///
    /// If you are planning to connect to the service, it is usually easier
    /// to create a `NetworkService` and use its `SocketConnectable`
    /// interface.
    /// ## `service`
    /// the service type to look up (eg, "ldap")
    /// ## `protocol`
    /// the networking protocol to use for `service` (eg, "tcp")
    /// ## `domain`
    /// the DNS domain to look up the service in
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    ///
    /// # Returns
    ///
    /// a non-empty `glib::List` of
    /// `SrvTarget`, or `None` on error. You must free each of the targets and the
    /// list when you are done with it. (You can use `Resolver::free_targets` to do
    /// this.)
    fn lookup_service<P: IsA<Cancellable>>(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
        cancellable: Option<&P>,
    ) -> Result<Vec<SrvTarget>, glib::Error>;

    /// Begins asynchronously performing a DNS SRV lookup for the given
    /// `service` and `protocol` in the given `domain`, and eventually calls
    /// `callback`, which must call `ResolverExt::lookup_service_finish` to
    /// get the final result. See `ResolverExt::lookup_service` for more
    /// details.
    /// ## `service`
    /// the service type to look up (eg, "ldap")
    /// ## `protocol`
    /// the networking protocol to use for `service` (eg, "tcp")
    /// ## `domain`
    /// the DNS domain to look up the service in
    /// ## `cancellable`
    /// a `Cancellable`, or `None`
    /// ## `callback`
    /// callback to call after resolution completes
    /// ## `user_data`
    /// data for `callback`
    fn lookup_service_async<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + Send + 'static,
    >(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
        cancellable: Option<&P>,
        callback: Q,
    );

    fn lookup_service_async_future(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<SrvTarget>, glib::Error>> + 'static>>;

    /// Sets `self` to be the application's default resolver (reffing
    /// `self`, and unreffing the previous default resolver, if any).
    /// Future calls to `Resolver::get_default` will return this resolver.
    ///
    /// This can be used if an application wants to perform any sort of DNS
    /// caching or "pinning"; it can implement its own `Resolver` that
    /// calls the original default resolver for DNS operations, and
    /// implements its own cache policies on top of that, and then set
    /// itself as the default resolver for all later code to use.
    fn set_default(&self);

    /// Emitted when the resolver notices that the system resolver
    /// configuration has changed.
    fn connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Resolver>> ResolverExt for O {
    fn lookup_by_address<P: IsA<InetAddress>, Q: IsA<Cancellable>>(
        &self,
        address: &P,
        cancellable: Option<&Q>,
    ) -> Result<GString, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_by_address(
                self.as_ref().to_glib_none().0,
                address.as_ref().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))
            }
        }
    }

    fn lookup_by_address_async<
        P: IsA<InetAddress>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<GString, glib::Error>) + Send + 'static,
    >(
        &self,
        address: &P,
        cancellable: Option<&Q>,
        callback: R,
    ) {
        let user_data: Box_<R> = Box_::new(callback);
        unsafe extern "C" fn lookup_by_address_async_trampoline<
            R: FnOnce(Result<GString, glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_by_address_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_<R> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = lookup_by_address_async_trampoline::<R>;
        unsafe {
            gio_sys::g_resolver_lookup_by_address_async(
                self.as_ref().to_glib_none().0,
                address.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 _,
            );
        }
    }

    fn lookup_by_address_async_future<P: IsA<InetAddress> + Clone + 'static>(
        &self,
        address: &P,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<GString, glib::Error>> + 'static>> {
        let address = address.clone();
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.lookup_by_address_async(&address, Some(&cancellable), move |res| {
                send.resolve(res);
            });

            cancellable
        }))
    }

    fn lookup_by_name<P: IsA<Cancellable>>(
        &self,
        hostname: &str,
        cancellable: Option<&P>,
    ) -> Result<Vec<InetAddress>, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_by_name(
                self.as_ref().to_glib_none().0,
                hostname.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn lookup_by_name_async<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static,
    >(
        &self,
        hostname: &str,
        cancellable: Option<&P>,
        callback: Q,
    ) {
        let user_data: Box_<Q> = Box_::new(callback);
        unsafe extern "C" fn lookup_by_name_async_trampoline<
            Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_by_name_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<Q> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = lookup_by_name_async_trampoline::<Q>;
        unsafe {
            gio_sys::g_resolver_lookup_by_name_async(
                self.as_ref().to_glib_none().0,
                hostname.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn lookup_by_name_async_future(
        &self,
        hostname: &str,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>
    {
        let hostname = String::from(hostname);
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.lookup_by_name_async(&hostname, Some(&cancellable), move |res| {
                send.resolve(res);
            });

            cancellable
        }))
    }

    #[cfg(any(feature = "v2_60", feature = "dox"))]
    fn lookup_by_name_with_flags<P: IsA<Cancellable>>(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
        cancellable: Option<&P>,
    ) -> Result<Vec<InetAddress>, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_by_name_with_flags(
                self.as_ref().to_glib_none().0,
                hostname.to_glib_none().0,
                flags.to_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[cfg(any(feature = "v2_60", feature = "dox"))]
    fn lookup_by_name_with_flags_async<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static,
    >(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
        cancellable: Option<&P>,
        callback: Q,
    ) {
        let user_data: Box_<Q> = Box_::new(callback);
        unsafe extern "C" fn lookup_by_name_with_flags_async_trampoline<
            Q: FnOnce(Result<Vec<InetAddress>, glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_by_name_with_flags_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<Q> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = lookup_by_name_with_flags_async_trampoline::<Q>;
        unsafe {
            gio_sys::g_resolver_lookup_by_name_with_flags_async(
                self.as_ref().to_glib_none().0,
                hostname.to_glib_none().0,
                flags.to_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(any(feature = "v2_60", feature = "dox"))]
    fn lookup_by_name_with_flags_async_future(
        &self,
        hostname: &str,
        flags: ResolverNameLookupFlags,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<InetAddress>, glib::Error>> + 'static>>
    {
        let hostname = String::from(hostname);
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.lookup_by_name_with_flags_async(&hostname, flags, Some(&cancellable), move |res| {
                send.resolve(res);
            });

            cancellable
        }))
    }

    fn lookup_records<P: IsA<Cancellable>>(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
        cancellable: Option<&P>,
    ) -> Result<Vec<glib::Variant>, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_records(
                self.as_ref().to_glib_none().0,
                rrname.to_glib_none().0,
                record_type.to_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn lookup_records_async<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + Send + 'static,
    >(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
        cancellable: Option<&P>,
        callback: Q,
    ) {
        let user_data: Box_<Q> = Box_::new(callback);
        unsafe extern "C" fn lookup_records_async_trampoline<
            Q: FnOnce(Result<Vec<glib::Variant>, glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_records_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<Q> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = lookup_records_async_trampoline::<Q>;
        unsafe {
            gio_sys::g_resolver_lookup_records_async(
                self.as_ref().to_glib_none().0,
                rrname.to_glib_none().0,
                record_type.to_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn lookup_records_async_future(
        &self,
        rrname: &str,
        record_type: ResolverRecordType,
    ) -> Pin<
        Box_<dyn std::future::Future<Output = Result<Vec<glib::Variant>, glib::Error>> + 'static>,
    > {
        let rrname = String::from(rrname);
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.lookup_records_async(&rrname, record_type, Some(&cancellable), move |res| {
                send.resolve(res);
            });

            cancellable
        }))
    }

    fn lookup_service<P: IsA<Cancellable>>(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
        cancellable: Option<&P>,
    ) -> Result<Vec<SrvTarget>, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_service(
                self.as_ref().to_glib_none().0,
                service.to_glib_none().0,
                protocol.to_glib_none().0,
                domain.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn lookup_service_async<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + Send + 'static,
    >(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
        cancellable: Option<&P>,
        callback: Q,
    ) {
        let user_data: Box_<Q> = Box_::new(callback);
        unsafe extern "C" fn lookup_service_async_trampoline<
            Q: FnOnce(Result<Vec<SrvTarget>, glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_resolver_lookup_service_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<Q> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = lookup_service_async_trampoline::<Q>;
        unsafe {
            gio_sys::g_resolver_lookup_service_async(
                self.as_ref().to_glib_none().0,
                service.to_glib_none().0,
                protocol.to_glib_none().0,
                domain.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn lookup_service_async_future(
        &self,
        service: &str,
        protocol: &str,
        domain: &str,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<SrvTarget>, glib::Error>> + 'static>>
    {
        let service = String::from(service);
        let protocol = String::from(protocol);
        let domain = String::from(domain);
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.lookup_service_async(
                &service,
                &protocol,
                &domain,
                Some(&cancellable),
                move |res| {
                    send.resolve(res);
                },
            );

            cancellable
        }))
    }

    fn set_default(&self) {
        unsafe {
            gio_sys::g_resolver_set_default(self.as_ref().to_glib_none().0);
        }
    }

    fn connect_reload<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn reload_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut gio_sys::GResolver,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Resolver>,
        {
            let f: &F = &*(f as *const F);
            f(&Resolver::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"reload\0".as_ptr() as *const _,
                Some(transmute(reload_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for Resolver {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Resolver")
    }
}