Trait ux::prelude::ResolverExt[−]

pub trait ResolverExt: 'static {

Show methods    pub fn lookup_by_address<P, Q>(
        &self, 
        address: &P, 
        cancellable: Option<&Q>
    ) -> Result<GString, Error>
    where
        P: IsA<InetAddress>,
        Q: IsA<Cancellable>;

    pub fn lookup_by_address_async<P, Q, R>(
        &self, 
        address: &P, 
        cancellable: Option<&Q>, 
        callback: R
    )
    where
        P: IsA<InetAddress>,
        Q: IsA<Cancellable>,
        R: 'static + FnOnce(Result<GString, Error>) + Send;

    pub fn lookup_by_address_async_future<P>(
        &self, 
        address: &P
    ) -> Pin<Box<dyn Future<Output = Result<GString, Error>> + 'static, Global>>
    where
        P: 'static + IsA<InetAddress> + Clone;

    pub fn lookup_by_name<P>(
        &self, 
        hostname: &str, 
        cancellable: Option<&P>
    ) -> Result<Vec<InetAddress, Global>, Error>
    where
        P: IsA<Cancellable>;

    pub fn lookup_by_name_async<P, Q>(
        &self, 
        hostname: &str, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<Vec<InetAddress, Global>, Error>) + Send;

    pub fn lookup_by_name_async_future(
        &self, 
        hostname: &str
    ) -> Pin<Box<dyn Future<Output = Result<Vec<InetAddress, Global>, Error>> + 'static, Global>>;

    pub fn lookup_records<P>(
        &self, 
        rrname: &str, 
        record_type: ResolverRecordType, 
        cancellable: Option<&P>
    ) -> Result<Vec<Variant, Global>, Error>
    where
        P: IsA<Cancellable>;

    pub fn lookup_records_async<P, Q>(
        &self, 
        rrname: &str, 
        record_type: ResolverRecordType, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<Vec<Variant, Global>, Error>) + Send;

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

    pub fn lookup_service<P>(
        &self, 
        service: &str, 
        protocol: &str, 
        domain: &str, 
        cancellable: Option<&P>
    ) -> Result<Vec<SrvTarget, Global>, Error>
    where
        P: IsA<Cancellable>;

    pub fn lookup_service_async<P, Q>(
        &self, 
        service: &str, 
        protocol: &str, 
        domain: &str, 
        cancellable: Option<&P>, 
        callback: Q
    )
    where
        P: IsA<Cancellable>,
        Q: 'static + FnOnce(Result<Vec<SrvTarget, Global>, Error>) + Send;

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

    pub fn set_default(&self);

    pub fn connect_reload<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self);

}

Required methods

pub fn lookup_by_address<P, Q>(
    &self,
    address: &P,
    cancellable: Option<&Q>
) -> Result<GString, Error> where
    P: IsA<InetAddress>,
    Q: IsA<Cancellable>, 

pub fn lookup_by_address_async<P, Q, R>(
    &self,
    address: &P,
    cancellable: Option<&Q>,
    callback: R
) where
    P: IsA<InetAddress>,
    Q: IsA<Cancellable>,
    R: 'static + FnOnce(Result<GString, Error>) + Send, 

pub fn lookup_by_address_async_future<P>(
    &self,
    address: &P
) -> Pin<Box<dyn Future<Output = Result<GString, Error>> + 'static, Global>> where
    P: 'static + IsA<InetAddress> + Clone, 

pub fn lookup_by_name<P>(
    &self,
    hostname: &str,
    cancellable: Option<&P>
) -> Result<Vec<InetAddress, Global>, Error> where
    P: IsA<Cancellable>, 

pub fn lookup_by_name_async<P, Q>(
    &self,
    hostname: &str,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<Vec<InetAddress, Global>, Error>) + Send, 

pub fn lookup_by_name_async_future(
    &self,
    hostname: &str
) -> Pin<Box<dyn Future<Output = Result<Vec<InetAddress, Global>, Error>> + 'static, Global>>

pub fn lookup_records<P>(
    &self,
    rrname: &str,
    record_type: ResolverRecordType,
    cancellable: Option<&P>
) -> Result<Vec<Variant, Global>, Error> where
    P: IsA<Cancellable>, 

pub fn lookup_records_async<P, Q>(
    &self,
    rrname: &str,
    record_type: ResolverRecordType,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<Vec<Variant, Global>, Error>) + Send, 

pub fn lookup_records_async_future(
    &self,
    rrname: &str,
    record_type: ResolverRecordType
) -> Pin<Box<dyn Future<Output = Result<Vec<Variant, Global>, Error>> + 'static, Global>>

pub fn lookup_service<P>(
    &self,
    service: &str,
    protocol: &str,
    domain: &str,
    cancellable: Option<&P>
) -> Result<Vec<SrvTarget, Global>, Error> where
    P: IsA<Cancellable>, 

pub fn lookup_service_async<P, Q>(
    &self,
    service: &str,
    protocol: &str,
    domain: &str,
    cancellable: Option<&P>,
    callback: Q
) where
    P: IsA<Cancellable>,
    Q: 'static + FnOnce(Result<Vec<SrvTarget, Global>, Error>) + Send, 

pub fn lookup_service_async_future(
    &self,
    service: &str,
    protocol: &str,
    domain: &str
) -> Pin<Box<dyn Future<Output = Result<Vec<SrvTarget, Global>, Error>> + 'static, Global>>

pub fn set_default(&self)

pub fn connect_reload<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 

Loading content...

Implementors

impl<O> ResolverExt for O where
    O: IsA<Resolver>, 

Loading content...