{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

'GI.Gio.Objects.Resolver.Resolver' provides cancellable synchronous and asynchronous DNS
resolution, for hostnames ('GI.Gio.Objects.Resolver.resolverLookupByAddress',
'GI.Gio.Objects.Resolver.resolverLookupByName' and their async variants) and SRV
(service) records ('GI.Gio.Objects.Resolver.resolverLookupService').

'GI.Gio.Objects.NetworkAddress.NetworkAddress' and 'GI.Gio.Objects.NetworkService.NetworkService' provide wrappers around
'GI.Gio.Objects.Resolver.Resolver' functionality that also implement 'GI.Gio.Interfaces.SocketConnectable.SocketConnectable',
making it easy to connect to a remote host\/service.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.Gio.Objects.Resolver
    ( 

-- * Exported types
    Resolver(..)                            ,
    IsResolver                              ,
    toResolver                              ,
    noResolver                              ,


 -- * Methods
-- ** getDefault #method:getDefault#

    resolverGetDefault                      ,


-- ** lookupByAddress #method:lookupByAddress#

#if ENABLE_OVERLOADING
    ResolverLookupByAddressMethodInfo       ,
#endif
    resolverLookupByAddress                 ,


-- ** lookupByAddressAsync #method:lookupByAddressAsync#

#if ENABLE_OVERLOADING
    ResolverLookupByAddressAsyncMethodInfo  ,
#endif
    resolverLookupByAddressAsync            ,


-- ** lookupByAddressFinish #method:lookupByAddressFinish#

#if ENABLE_OVERLOADING
    ResolverLookupByAddressFinishMethodInfo ,
#endif
    resolverLookupByAddressFinish           ,


-- ** lookupByName #method:lookupByName#

#if ENABLE_OVERLOADING
    ResolverLookupByNameMethodInfo          ,
#endif
    resolverLookupByName                    ,


-- ** lookupByNameAsync #method:lookupByNameAsync#

#if ENABLE_OVERLOADING
    ResolverLookupByNameAsyncMethodInfo     ,
#endif
    resolverLookupByNameAsync               ,


-- ** lookupByNameFinish #method:lookupByNameFinish#

#if ENABLE_OVERLOADING
    ResolverLookupByNameFinishMethodInfo    ,
#endif
    resolverLookupByNameFinish              ,


-- ** lookupByNameWithFlags #method:lookupByNameWithFlags#

#if ENABLE_OVERLOADING
    ResolverLookupByNameWithFlagsMethodInfo ,
#endif
    resolverLookupByNameWithFlags           ,


-- ** lookupByNameWithFlagsAsync #method:lookupByNameWithFlagsAsync#

#if ENABLE_OVERLOADING
    ResolverLookupByNameWithFlagsAsyncMethodInfo,
#endif
    resolverLookupByNameWithFlagsAsync      ,


-- ** lookupByNameWithFlagsFinish #method:lookupByNameWithFlagsFinish#

#if ENABLE_OVERLOADING
    ResolverLookupByNameWithFlagsFinishMethodInfo,
#endif
    resolverLookupByNameWithFlagsFinish     ,


-- ** lookupRecords #method:lookupRecords#

#if ENABLE_OVERLOADING
    ResolverLookupRecordsMethodInfo         ,
#endif
    resolverLookupRecords                   ,


-- ** lookupRecordsAsync #method:lookupRecordsAsync#

#if ENABLE_OVERLOADING
    ResolverLookupRecordsAsyncMethodInfo    ,
#endif
    resolverLookupRecordsAsync              ,


-- ** lookupRecordsFinish #method:lookupRecordsFinish#

#if ENABLE_OVERLOADING
    ResolverLookupRecordsFinishMethodInfo   ,
#endif
    resolverLookupRecordsFinish             ,


-- ** lookupService #method:lookupService#

#if ENABLE_OVERLOADING
    ResolverLookupServiceMethodInfo         ,
#endif
    resolverLookupService                   ,


-- ** lookupServiceAsync #method:lookupServiceAsync#

#if ENABLE_OVERLOADING
    ResolverLookupServiceAsyncMethodInfo    ,
#endif
    resolverLookupServiceAsync              ,


-- ** lookupServiceFinish #method:lookupServiceFinish#

#if ENABLE_OVERLOADING
    ResolverLookupServiceFinishMethodInfo   ,
#endif
    resolverLookupServiceFinish             ,


-- ** setDefault #method:setDefault#

#if ENABLE_OVERLOADING
    ResolverSetDefaultMethodInfo            ,
#endif
    resolverSetDefault                      ,




 -- * Signals
-- ** reload #signal:reload#

    C_ResolverReloadCallback                ,
    ResolverReloadCallback                  ,
#if ENABLE_OVERLOADING
    ResolverReloadSignalInfo                ,
#endif
    afterResolverReload                     ,
    genClosure_ResolverReload               ,
    mk_ResolverReloadCallback               ,
    noResolverReloadCallback                ,
    onResolverReload                        ,
    wrap_ResolverReloadCallback             ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.InetAddress as Gio.InetAddress
import {-# SOURCE #-} qualified GI.Gio.Structs.SrvTarget as Gio.SrvTarget

-- | Memory-managed wrapper type.
newtype Resolver = Resolver (ManagedPtr Resolver)
foreign import ccall "g_resolver_get_type"
    c_g_resolver_get_type :: IO GType

instance GObject Resolver where
    gobjectType :: Resolver -> IO GType
gobjectType _ = IO GType
c_g_resolver_get_type
    

-- | Type class for types which can be safely cast to `Resolver`, for instance with `toResolver`.
class GObject o => IsResolver o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Resolver a) =>
    IsResolver a
#endif
instance IsResolver Resolver
instance GObject.Object.IsObject Resolver

-- | Cast to `Resolver`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toResolver :: (MonadIO m, IsResolver o) => o -> m Resolver
toResolver :: o -> m Resolver
toResolver = IO Resolver -> m Resolver
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Resolver -> m Resolver)
-> (o -> IO Resolver) -> o -> m Resolver
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Resolver -> Resolver) -> o -> IO Resolver
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr Resolver -> Resolver
Resolver

-- | A convenience alias for `Nothing` :: `Maybe` `Resolver`.
noResolver :: Maybe Resolver
noResolver :: Maybe Resolver
noResolver = Maybe Resolver
forall a. Maybe a
Nothing

#if ENABLE_OVERLOADING
type family ResolveResolverMethod (t :: Symbol) (o :: *) :: * where
    ResolveResolverMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveResolverMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveResolverMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveResolverMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveResolverMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveResolverMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveResolverMethod "lookupByAddress" o = ResolverLookupByAddressMethodInfo
    ResolveResolverMethod "lookupByAddressAsync" o = ResolverLookupByAddressAsyncMethodInfo
    ResolveResolverMethod "lookupByAddressFinish" o = ResolverLookupByAddressFinishMethodInfo
    ResolveResolverMethod "lookupByName" o = ResolverLookupByNameMethodInfo
    ResolveResolverMethod "lookupByNameAsync" o = ResolverLookupByNameAsyncMethodInfo
    ResolveResolverMethod "lookupByNameFinish" o = ResolverLookupByNameFinishMethodInfo
    ResolveResolverMethod "lookupByNameWithFlags" o = ResolverLookupByNameWithFlagsMethodInfo
    ResolveResolverMethod "lookupByNameWithFlagsAsync" o = ResolverLookupByNameWithFlagsAsyncMethodInfo
    ResolveResolverMethod "lookupByNameWithFlagsFinish" o = ResolverLookupByNameWithFlagsFinishMethodInfo
    ResolveResolverMethod "lookupRecords" o = ResolverLookupRecordsMethodInfo
    ResolveResolverMethod "lookupRecordsAsync" o = ResolverLookupRecordsAsyncMethodInfo
    ResolveResolverMethod "lookupRecordsFinish" o = ResolverLookupRecordsFinishMethodInfo
    ResolveResolverMethod "lookupService" o = ResolverLookupServiceMethodInfo
    ResolveResolverMethod "lookupServiceAsync" o = ResolverLookupServiceAsyncMethodInfo
    ResolveResolverMethod "lookupServiceFinish" o = ResolverLookupServiceFinishMethodInfo
    ResolveResolverMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveResolverMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveResolverMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveResolverMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveResolverMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveResolverMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveResolverMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveResolverMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveResolverMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveResolverMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveResolverMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveResolverMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveResolverMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveResolverMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveResolverMethod "setDefault" o = ResolverSetDefaultMethodInfo
    ResolveResolverMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveResolverMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveResolverMethod t Resolver, O.MethodInfo info Resolver p) => O.IsLabelProxy t (Resolver -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveResolverMethod t Resolver, O.MethodInfo info Resolver p) => O.IsLabel t (Resolver -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif

-- signal Resolver::reload
{- |
Emitted when the resolver notices that the system resolver
configuration has changed.
-}
type ResolverReloadCallback =
    IO ()

-- | A convenience synonym for @`Nothing` :: `Maybe` `ResolverReloadCallback`@.
noResolverReloadCallback :: Maybe ResolverReloadCallback
noResolverReloadCallback :: Maybe ResolverReloadCallback
noResolverReloadCallback = Maybe ResolverReloadCallback
forall a. Maybe a
Nothing

-- | Type for the callback on the (unwrapped) C side.
type C_ResolverReloadCallback =
    Ptr () ->                               -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ResolverReloadCallback`.
foreign import ccall "wrapper"
    mk_ResolverReloadCallback :: C_ResolverReloadCallback -> IO (FunPtr C_ResolverReloadCallback)

-- | Wrap the callback into a `Closure`.
genClosure_ResolverReload :: ResolverReloadCallback -> IO Closure
genClosure_ResolverReload :: ResolverReloadCallback -> IO Closure
genClosure_ResolverReload cb :: ResolverReloadCallback
cb = do
    let cb' :: C_ResolverReloadCallback
cb' = ResolverReloadCallback -> C_ResolverReloadCallback
wrap_ResolverReloadCallback ResolverReloadCallback
cb
    C_ResolverReloadCallback -> IO (FunPtr C_ResolverReloadCallback)
mk_ResolverReloadCallback C_ResolverReloadCallback
cb' IO (FunPtr C_ResolverReloadCallback)
-> (FunPtr C_ResolverReloadCallback -> IO Closure) -> IO Closure
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= FunPtr C_ResolverReloadCallback -> IO Closure
forall a. FunPtr a -> IO Closure
newCClosure


-- | Wrap a `ResolverReloadCallback` into a `C_ResolverReloadCallback`.
wrap_ResolverReloadCallback ::
    ResolverReloadCallback ->
    C_ResolverReloadCallback
wrap_ResolverReloadCallback :: ResolverReloadCallback -> C_ResolverReloadCallback
wrap_ResolverReloadCallback _cb :: ResolverReloadCallback
_cb _ _ = do
    ResolverReloadCallback
_cb 


{- |
Connect a signal handler for the “@reload@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.on' resolver #reload callback
@
-}
onResolverReload :: (IsResolver a, MonadIO m) => a -> ResolverReloadCallback -> m SignalHandlerId
onResolverReload :: a -> ResolverReloadCallback -> m SignalHandlerId
onResolverReload obj :: a
obj cb :: ResolverReloadCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ResolverReloadCallback
cb' = ResolverReloadCallback -> C_ResolverReloadCallback
wrap_ResolverReloadCallback ResolverReloadCallback
cb
    FunPtr C_ResolverReloadCallback
cb'' <- C_ResolverReloadCallback -> IO (FunPtr C_ResolverReloadCallback)
mk_ResolverReloadCallback C_ResolverReloadCallback
cb'
    a
-> String
-> FunPtr C_ResolverReloadCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "reload" FunPtr C_ResolverReloadCallback
cb'' SignalConnectMode
SignalConnectBefore

{- |
Connect a signal handler for the “@reload@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Signals.after' resolver #reload callback
@
-}
afterResolverReload :: (IsResolver a, MonadIO m) => a -> ResolverReloadCallback -> m SignalHandlerId
afterResolverReload :: a -> ResolverReloadCallback -> m SignalHandlerId
afterResolverReload obj :: a
obj cb :: ResolverReloadCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let cb' :: C_ResolverReloadCallback
cb' = ResolverReloadCallback -> C_ResolverReloadCallback
wrap_ResolverReloadCallback ResolverReloadCallback
cb
    FunPtr C_ResolverReloadCallback
cb'' <- C_ResolverReloadCallback -> IO (FunPtr C_ResolverReloadCallback)
mk_ResolverReloadCallback C_ResolverReloadCallback
cb'
    a
-> String
-> FunPtr C_ResolverReloadCallback
-> SignalConnectMode
-> IO SignalHandlerId
forall o a.
GObject o =>
o -> String -> FunPtr a -> SignalConnectMode -> IO SignalHandlerId
connectSignalFunPtr a
obj "reload" FunPtr C_ResolverReloadCallback
cb'' SignalConnectMode
SignalConnectAfter


#if ENABLE_OVERLOADING
instance O.HasAttributeList Resolver
type instance O.AttributeList Resolver = ResolverAttributeList
type ResolverAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
#endif

#if ENABLE_OVERLOADING
data ResolverReloadSignalInfo
instance SignalInfo ResolverReloadSignalInfo where
    type HaskellCallbackType ResolverReloadSignalInfo = ResolverReloadCallback
    connectSignal _ obj cb connectMode = do
        let cb' = wrap_ResolverReloadCallback cb
        cb'' <- mk_ResolverReloadCallback cb'
        connectSignalFunPtr obj "reload" cb'' connectMode

type instance O.SignalList Resolver = ResolverSignalList
type ResolverSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo), '("reload", ResolverReloadSignalInfo)] :: [(Symbol, *)])

#endif

-- method Resolver::lookup_by_address
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "InetAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the address to reverse-resolve", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_address" g_resolver_lookup_by_address :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    Ptr Gio.InetAddress.InetAddress ->      -- address : TInterface (Name {namespace = "Gio", name = "InetAddress"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO CString

{- |
Synchronously reverse-resolves /@address@/ to determine its
associated hostname.

If the DNS resolution fails, /@error@/ (if non-'Nothing') will be set to
a value from 'GI.Gio.Enums.ResolverError'.

If /@cancellable@/ is non-'Nothing', it can be used to cancel the
operation, in which case /@error@/ (if non-'Nothing') will be set to
'GI.Gio.Enums.IOErrorEnumCancelled'.

/Since: 2.22/
-}
resolverLookupByAddress ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.InetAddress.IsInetAddress b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> b
    {- ^ /@address@/: the address to reverse-resolve -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> m T.Text
    {- ^ __Returns:__ a hostname (either ASCII-only, or in ASCII-encoded
    form), or 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupByAddress :: a -> b -> Maybe c -> m Text
resolverLookupByAddress resolver :: a
resolver address :: b
address cancellable :: Maybe c
cancellable = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr InetAddress
address' <- b -> IO (Ptr InetAddress)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
address
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO Text -> ResolverReloadCallback -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
        CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> Ptr InetAddress
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CString
g_resolver_lookup_by_address Ptr Resolver
resolver' Ptr InetAddress
address' Ptr Cancellable
maybeCancellable
        Text -> CString -> ResolverReloadCallback
forall a. HasCallStack => Text -> Ptr a -> ResolverReloadCallback
checkUnexpectedReturnNULL "resolverLookupByAddress" CString
result
        Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr b
address
        Maybe c -> (c -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
     ) (do
        () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data ResolverLookupByAddressMethodInfo
instance (signature ~ (b -> Maybe (c) -> m T.Text), MonadIO m, IsResolver a, Gio.InetAddress.IsInetAddress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo ResolverLookupByAddressMethodInfo a signature where
    overloadedMethod _ = resolverLookupByAddress

#endif

-- method Resolver::lookup_by_address_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "InetAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the address to reverse-resolve", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call after resolution completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_address_async" g_resolver_lookup_by_address_async :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    Ptr Gio.InetAddress.InetAddress ->      -- address : TInterface (Name {namespace = "Gio", name = "InetAddress"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Begins asynchronously reverse-resolving /@address@/ to determine its
associated hostname, and eventually calls /@callback@/, which must
call 'GI.Gio.Objects.Resolver.resolverLookupByAddressFinish' to get the final result.

/Since: 2.22/
-}
resolverLookupByAddressAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.InetAddress.IsInetAddress b, Gio.Cancellable.IsCancellable c) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> b
    {- ^ /@address@/: the address to reverse-resolve -}
    -> Maybe (c)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: callback to call after resolution completes -}
    -> m ()
resolverLookupByAddressAsync :: a -> b -> Maybe c -> Maybe AsyncReadyCallback -> m ()
resolverLookupByAddressAsync resolver :: a
resolver address :: b
address cancellable :: Maybe c
cancellable callback :: Maybe AsyncReadyCallback
callback = ResolverReloadCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ResolverReloadCallback -> m ()) -> ResolverReloadCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr InetAddress
address' <- b -> IO (Ptr InetAddress)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
address
    Ptr Cancellable
maybeCancellable <- case Maybe c
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: c
jCancellable -> do
            Ptr Cancellable
jCancellable' <- c -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr c
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> ResolverReloadCallback
forall a. Storable a => Ptr a -> a -> ResolverReloadCallback
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Resolver
-> Ptr InetAddress
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> ResolverReloadCallback
g_resolver_lookup_by_address_async Ptr Resolver
resolver' Ptr InetAddress
address' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
    b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr b
address
    Maybe c -> (c -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe c
cancellable c -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
    () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data ResolverLookupByAddressAsyncMethodInfo
instance (signature ~ (b -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsResolver a, Gio.InetAddress.IsInetAddress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo ResolverLookupByAddressAsyncMethodInfo a signature where
    overloadedMethod _ = resolverLookupByAddressAsync

#endif

-- method Resolver::lookup_by_address_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the result passed to your #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_address_finish" g_resolver_lookup_by_address_finish :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO CString

{- |
Retrieves the result of a previous call to
'GI.Gio.Objects.Resolver.resolverLookupByAddressAsync'.

If the DNS resolution failed, /@error@/ (if non-'Nothing') will be set to
a value from 'GI.Gio.Enums.ResolverError'. If the operation was cancelled,
/@error@/ will be set to 'GI.Gio.Enums.IOErrorEnumCancelled'.

/Since: 2.22/
-}
resolverLookupByAddressFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> b
    {- ^ /@result@/: the result passed to your 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m T.Text
    {- ^ __Returns:__ a hostname (either ASCII-only, or in ASCII-encoded
form), or 'Nothing' on error. /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupByAddressFinish :: a -> b -> m Text
resolverLookupByAddressFinish resolver :: a
resolver result_ :: b
result_ = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO Text -> ResolverReloadCallback -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
        CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ Ptr Resolver -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CString
g_resolver_lookup_by_address_finish Ptr Resolver
resolver' Ptr AsyncResult
result_'
        Text -> CString -> ResolverReloadCallback
forall a. HasCallStack => Text -> Ptr a -> ResolverReloadCallback
checkUnexpectedReturnNULL "resolverLookupByAddressFinish" CString
result
        Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr b
result_
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
     ) (do
        () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data ResolverLookupByAddressFinishMethodInfo
instance (signature ~ (b -> m T.Text), MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo ResolverLookupByAddressFinishMethodInfo a signature where
    overloadedMethod _ = resolverLookupByAddressFinish

#endif

-- method Resolver::lookup_by_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hostname to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "InetAddress"})))
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_name" g_resolver_lookup_by_name :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    CString ->                              -- hostname : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr Gio.InetAddress.InetAddress)))

{- |
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 'GI.Gio.Objects.InetAddress.inetAddressNewFromString').

On success, 'GI.Gio.Objects.Resolver.resolverLookupByName' will return a non-empty 'GI.GLib.Structs.List.List' of
'GI.Gio.Objects.InetAddress.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. 'GI.Gio.Objects.SocketListener.socketListenerAddAddress'.

If the DNS resolution fails, /@error@/ (if non-'Nothing') will be set to a
value from 'GI.Gio.Enums.ResolverError' and 'Nothing' will be returned.

If /@cancellable@/ is non-'Nothing', it can be used to cancel the
operation, in which case /@error@/ (if non-'Nothing') will be set to
'GI.Gio.Enums.IOErrorEnumCancelled'.

If you are planning to connect to a socket on the resolved IP
address, it may be easier to create a 'GI.Gio.Objects.NetworkAddress.NetworkAddress' and use its
'GI.Gio.Interfaces.SocketConnectable.SocketConnectable' interface.

/Since: 2.22/
-}
resolverLookupByName ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> T.Text
    {- ^ /@hostname@/: the hostname to look up -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> m [Gio.InetAddress.InetAddress]
    {- ^ __Returns:__ a non-empty 'GI.GLib.Structs.List.List'
of 'GI.Gio.Objects.InetAddress.InetAddress', or 'Nothing' on error. You
must unref each of the addresses and free the list when you are
done with it. (You can use @/g_resolver_free_addresses()/@ to do this.) /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupByName :: a -> Text -> Maybe b -> m [InetAddress]
resolverLookupByName resolver :: a
resolver hostname :: Text
hostname cancellable :: Maybe b
cancellable = IO [InetAddress] -> m [InetAddress]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [InetAddress] -> m [InetAddress])
-> IO [InetAddress] -> m [InetAddress]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    CString
hostname' <- Text -> IO CString
textToCString Text
hostname
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO [InetAddress] -> ResolverReloadCallback -> IO [InetAddress]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr InetAddress))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
-> IO (Ptr (GList (Ptr InetAddress)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
 -> IO (Ptr (GList (Ptr InetAddress))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
-> IO (Ptr (GList (Ptr InetAddress)))
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr InetAddress)))
g_resolver_lookup_by_name Ptr Resolver
resolver' CString
hostname' Ptr Cancellable
maybeCancellable
        [Ptr InetAddress]
result' <- Ptr (GList (Ptr InetAddress)) -> IO [Ptr InetAddress]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr InetAddress))
result
        [InetAddress]
result'' <- (Ptr InetAddress -> IO InetAddress)
-> [Ptr InetAddress] -> IO [InetAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr InetAddress -> InetAddress)
-> Ptr InetAddress -> IO InetAddress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InetAddress -> InetAddress
Gio.InetAddress.InetAddress) [Ptr InetAddress]
result'
        Ptr (GList (Ptr InetAddress)) -> ResolverReloadCallback
forall a. Ptr (GList a) -> ResolverReloadCallback
g_list_free Ptr (GList (Ptr InetAddress))
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        Maybe b -> (b -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
hostname'
        [InetAddress] -> IO [InetAddress]
forall (m :: * -> *) a. Monad m => a -> m a
return [InetAddress]
result''
     ) (do
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
hostname'
     )

#if ENABLE_OVERLOADING
data ResolverLookupByNameMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m [Gio.InetAddress.InetAddress]), MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo ResolverLookupByNameMethodInfo a signature where
    overloadedMethod _ = resolverLookupByName

#endif

-- method Resolver::lookup_by_name_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hostname to look up the address of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call after resolution completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_name_async" g_resolver_lookup_by_name_async :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    CString ->                              -- hostname : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Begins asynchronously resolving /@hostname@/ to determine its
associated IP address(es), and eventually calls /@callback@/, which
must call 'GI.Gio.Objects.Resolver.resolverLookupByNameFinish' to get the result.
See 'GI.Gio.Objects.Resolver.resolverLookupByName' for more details.

/Since: 2.22/
-}
resolverLookupByNameAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> T.Text
    {- ^ /@hostname@/: the hostname to look up the address of -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: callback to call after resolution completes -}
    -> m ()
resolverLookupByNameAsync :: a -> Text -> Maybe b -> Maybe AsyncReadyCallback -> m ()
resolverLookupByNameAsync resolver :: a
resolver hostname :: Text
hostname cancellable :: Maybe b
cancellable callback :: Maybe AsyncReadyCallback
callback = ResolverReloadCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ResolverReloadCallback -> m ()) -> ResolverReloadCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    CString
hostname' <- Text -> IO CString
textToCString Text
hostname
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> ResolverReloadCallback
forall a. Storable a => Ptr a -> a -> ResolverReloadCallback
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Resolver
-> CString
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> ResolverReloadCallback
g_resolver_lookup_by_name_async Ptr Resolver
resolver' CString
hostname' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
    Maybe b -> (b -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
    CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
hostname'
    () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data ResolverLookupByNameAsyncMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo ResolverLookupByNameAsyncMethodInfo a signature where
    overloadedMethod _ = resolverLookupByNameAsync

#endif

-- method Resolver::lookup_by_name_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the result passed to your #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "InetAddress"})))
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_name_finish" g_resolver_lookup_by_name_finish :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr Gio.InetAddress.InetAddress)))

{- |
Retrieves the result of a call to
'GI.Gio.Objects.Resolver.resolverLookupByNameAsync'.

If the DNS resolution failed, /@error@/ (if non-'Nothing') will be set to
a value from 'GI.Gio.Enums.ResolverError'. If the operation was cancelled,
/@error@/ will be set to 'GI.Gio.Enums.IOErrorEnumCancelled'.

/Since: 2.22/
-}
resolverLookupByNameFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> b
    {- ^ /@result@/: the result passed to your 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m [Gio.InetAddress.InetAddress]
    {- ^ __Returns:__ a 'GI.GLib.Structs.List.List'
of 'GI.Gio.Objects.InetAddress.InetAddress', or 'Nothing' on error. See 'GI.Gio.Objects.Resolver.resolverLookupByName'
for more details. /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupByNameFinish :: a -> b -> m [InetAddress]
resolverLookupByNameFinish resolver :: a
resolver result_ :: b
result_ = IO [InetAddress] -> m [InetAddress]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [InetAddress] -> m [InetAddress])
-> IO [InetAddress] -> m [InetAddress]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO [InetAddress] -> ResolverReloadCallback -> IO [InetAddress]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr InetAddress))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
-> IO (Ptr (GList (Ptr InetAddress)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
 -> IO (Ptr (GList (Ptr InetAddress))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
-> IO (Ptr (GList (Ptr InetAddress)))
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> Ptr AsyncResult
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr InetAddress)))
g_resolver_lookup_by_name_finish Ptr Resolver
resolver' Ptr AsyncResult
result_'
        [Ptr InetAddress]
result' <- Ptr (GList (Ptr InetAddress)) -> IO [Ptr InetAddress]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr InetAddress))
result
        [InetAddress]
result'' <- (Ptr InetAddress -> IO InetAddress)
-> [Ptr InetAddress] -> IO [InetAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr InetAddress -> InetAddress)
-> Ptr InetAddress -> IO InetAddress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InetAddress -> InetAddress
Gio.InetAddress.InetAddress) [Ptr InetAddress]
result'
        Ptr (GList (Ptr InetAddress)) -> ResolverReloadCallback
forall a. Ptr (GList a) -> ResolverReloadCallback
g_list_free Ptr (GList (Ptr InetAddress))
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr b
result_
        [InetAddress] -> IO [InetAddress]
forall (m :: * -> *) a. Monad m => a -> m a
return [InetAddress]
result''
     ) (do
        () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data ResolverLookupByNameFinishMethodInfo
instance (signature ~ (b -> m [Gio.InetAddress.InetAddress]), MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo ResolverLookupByNameFinishMethodInfo a signature where
    overloadedMethod _ = resolverLookupByNameFinish

#endif

-- method Resolver::lookup_by_name_with_flags
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hostname to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "ResolverNameLookupFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "extra #GResolverNameLookupFlags for the lookup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "InetAddress"})))
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_name_with_flags" g_resolver_lookup_by_name_with_flags :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    CString ->                              -- hostname : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "ResolverNameLookupFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr Gio.InetAddress.InetAddress)))

{- |
This differs from 'GI.Gio.Objects.Resolver.resolverLookupByName' in that you can modify
the lookup behavior with /@flags@/. For example this can be used to limit
results with @/G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY/@.

/Since: 2.60/
-}
resolverLookupByNameWithFlags ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> T.Text
    {- ^ /@hostname@/: the hostname to look up -}
    -> [Gio.Flags.ResolverNameLookupFlags]
    {- ^ /@flags@/: extra 'GI.Gio.Flags.ResolverNameLookupFlags' for the lookup -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> m [Gio.InetAddress.InetAddress]
    {- ^ __Returns:__ a non-empty 'GI.GLib.Structs.List.List'
of 'GI.Gio.Objects.InetAddress.InetAddress', or 'Nothing' on error. You
must unref each of the addresses and free the list when you are
done with it. (You can use @/g_resolver_free_addresses()/@ to do this.) /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupByNameWithFlags :: a
-> Text -> [ResolverNameLookupFlags] -> Maybe b -> m [InetAddress]
resolverLookupByNameWithFlags resolver :: a
resolver hostname :: Text
hostname flags :: [ResolverNameLookupFlags]
flags cancellable :: Maybe b
cancellable = IO [InetAddress] -> m [InetAddress]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [InetAddress] -> m [InetAddress])
-> IO [InetAddress] -> m [InetAddress]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    CString
hostname' <- Text -> IO CString
textToCString Text
hostname
    let flags' :: CUInt
flags' = [ResolverNameLookupFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ResolverNameLookupFlags]
flags
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO [InetAddress] -> ResolverReloadCallback -> IO [InetAddress]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr InetAddress))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
-> IO (Ptr (GList (Ptr InetAddress)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
 -> IO (Ptr (GList (Ptr InetAddress))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
-> IO (Ptr (GList (Ptr InetAddress)))
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> CString
-> CUInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr InetAddress)))
g_resolver_lookup_by_name_with_flags Ptr Resolver
resolver' CString
hostname' CUInt
flags' Ptr Cancellable
maybeCancellable
        [Ptr InetAddress]
result' <- Ptr (GList (Ptr InetAddress)) -> IO [Ptr InetAddress]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr InetAddress))
result
        [InetAddress]
result'' <- (Ptr InetAddress -> IO InetAddress)
-> [Ptr InetAddress] -> IO [InetAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr InetAddress -> InetAddress)
-> Ptr InetAddress -> IO InetAddress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InetAddress -> InetAddress
Gio.InetAddress.InetAddress) [Ptr InetAddress]
result'
        Ptr (GList (Ptr InetAddress)) -> ResolverReloadCallback
forall a. Ptr (GList a) -> ResolverReloadCallback
g_list_free Ptr (GList (Ptr InetAddress))
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        Maybe b -> (b -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
hostname'
        [InetAddress] -> IO [InetAddress]
forall (m :: * -> *) a. Monad m => a -> m a
return [InetAddress]
result''
     ) (do
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
hostname'
     )

#if ENABLE_OVERLOADING
data ResolverLookupByNameWithFlagsMethodInfo
instance (signature ~ (T.Text -> [Gio.Flags.ResolverNameLookupFlags] -> Maybe (b) -> m [Gio.InetAddress.InetAddress]), MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo ResolverLookupByNameWithFlagsMethodInfo a signature where
    overloadedMethod _ = resolverLookupByNameWithFlags

#endif

-- method Resolver::lookup_by_name_with_flags_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "hostname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the hostname to look up the address of", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "ResolverNameLookupFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "extra #GResolverNameLookupFlags for the lookup", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call after resolution completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_name_with_flags_async" g_resolver_lookup_by_name_with_flags_async :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    CString ->                              -- hostname : TBasicType TUTF8
    CUInt ->                                -- flags : TInterface (Name {namespace = "Gio", name = "ResolverNameLookupFlags"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Begins asynchronously resolving /@hostname@/ to determine its
associated IP address(es), and eventually calls /@callback@/, which
must call 'GI.Gio.Objects.Resolver.resolverLookupByNameWithFlagsFinish' to get the result.
See 'GI.Gio.Objects.Resolver.resolverLookupByName' for more details.

/Since: 2.60/
-}
resolverLookupByNameWithFlagsAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> T.Text
    {- ^ /@hostname@/: the hostname to look up the address of -}
    -> [Gio.Flags.ResolverNameLookupFlags]
    {- ^ /@flags@/: extra 'GI.Gio.Flags.ResolverNameLookupFlags' for the lookup -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: callback to call after resolution completes -}
    -> m ()
resolverLookupByNameWithFlagsAsync :: a
-> Text
-> [ResolverNameLookupFlags]
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
resolverLookupByNameWithFlagsAsync resolver :: a
resolver hostname :: Text
hostname flags :: [ResolverNameLookupFlags]
flags cancellable :: Maybe b
cancellable callback :: Maybe AsyncReadyCallback
callback = ResolverReloadCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ResolverReloadCallback -> m ()) -> ResolverReloadCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    CString
hostname' <- Text -> IO CString
textToCString Text
hostname
    let flags' :: CUInt
flags' = [ResolverNameLookupFlags] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [ResolverNameLookupFlags]
flags
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> ResolverReloadCallback
forall a. Storable a => Ptr a -> a -> ResolverReloadCallback
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Resolver
-> CString
-> CUInt
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> ResolverReloadCallback
g_resolver_lookup_by_name_with_flags_async Ptr Resolver
resolver' CString
hostname' CUInt
flags' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
    Maybe b -> (b -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
    CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
hostname'
    () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data ResolverLookupByNameWithFlagsAsyncMethodInfo
instance (signature ~ (T.Text -> [Gio.Flags.ResolverNameLookupFlags] -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo ResolverLookupByNameWithFlagsAsyncMethodInfo a signature where
    overloadedMethod _ = resolverLookupByNameWithFlagsAsync

#endif

-- method Resolver::lookup_by_name_with_flags_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the result passed to your #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "InetAddress"})))
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_by_name_with_flags_finish" g_resolver_lookup_by_name_with_flags_finish :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr Gio.InetAddress.InetAddress)))

{- |
Retrieves the result of a call to
'GI.Gio.Objects.Resolver.resolverLookupByNameWithFlagsAsync'.

If the DNS resolution failed, /@error@/ (if non-'Nothing') will be set to
a value from 'GI.Gio.Enums.ResolverError'. If the operation was cancelled,
/@error@/ will be set to 'GI.Gio.Enums.IOErrorEnumCancelled'.

/Since: 2.60/
-}
resolverLookupByNameWithFlagsFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> b
    {- ^ /@result@/: the result passed to your 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m [Gio.InetAddress.InetAddress]
    {- ^ __Returns:__ a 'GI.GLib.Structs.List.List'
of 'GI.Gio.Objects.InetAddress.InetAddress', or 'Nothing' on error. See 'GI.Gio.Objects.Resolver.resolverLookupByName'
for more details. /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupByNameWithFlagsFinish :: a -> b -> m [InetAddress]
resolverLookupByNameWithFlagsFinish resolver :: a
resolver result_ :: b
result_ = IO [InetAddress] -> m [InetAddress]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [InetAddress] -> m [InetAddress])
-> IO [InetAddress] -> m [InetAddress]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO [InetAddress] -> ResolverReloadCallback -> IO [InetAddress]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr InetAddress))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
-> IO (Ptr (GList (Ptr InetAddress)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
 -> IO (Ptr (GList (Ptr InetAddress))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr InetAddress))))
-> IO (Ptr (GList (Ptr InetAddress)))
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> Ptr AsyncResult
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr InetAddress)))
g_resolver_lookup_by_name_with_flags_finish Ptr Resolver
resolver' Ptr AsyncResult
result_'
        [Ptr InetAddress]
result' <- Ptr (GList (Ptr InetAddress)) -> IO [Ptr InetAddress]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr InetAddress))
result
        [InetAddress]
result'' <- (Ptr InetAddress -> IO InetAddress)
-> [Ptr InetAddress] -> IO [InetAddress]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr InetAddress -> InetAddress)
-> Ptr InetAddress -> IO InetAddress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InetAddress -> InetAddress
Gio.InetAddress.InetAddress) [Ptr InetAddress]
result'
        Ptr (GList (Ptr InetAddress)) -> ResolverReloadCallback
forall a. Ptr (GList a) -> ResolverReloadCallback
g_list_free Ptr (GList (Ptr InetAddress))
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr b
result_
        [InetAddress] -> IO [InetAddress]
forall (m :: * -> *) a. Monad m => a -> m a
return [InetAddress]
result''
     ) (do
        () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data ResolverLookupByNameWithFlagsFinishMethodInfo
instance (signature ~ (b -> m [Gio.InetAddress.InetAddress]), MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo ResolverLookupByNameWithFlagsFinishMethodInfo a signature where
    overloadedMethod _ = resolverLookupByNameWithFlagsFinish

#endif

-- method Resolver::lookup_records
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rrname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the DNS name to look up the record for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "record_type", argType = TInterface (Name {namespace = "Gio", name = "ResolverRecordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of DNS record to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList TVariant)
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_records" g_resolver_lookup_records :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    CString ->                              -- rrname : TBasicType TUTF8
    CUInt ->                                -- record_type : TInterface (Name {namespace = "Gio", name = "ResolverRecordType"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr GVariant)))

{- |
Synchronously performs a DNS record lookup for the given /@rrname@/ and returns
a list of records as 'GVariant' tuples. See 'GI.Gio.Enums.ResolverRecordType' for
information on what the records contain for each /@recordType@/.

If the DNS resolution fails, /@error@/ (if non-'Nothing') will be set to
a value from 'GI.Gio.Enums.ResolverError' and 'Nothing' will be returned.

If /@cancellable@/ is non-'Nothing', it can be used to cancel the
operation, in which case /@error@/ (if non-'Nothing') will be set to
'GI.Gio.Enums.IOErrorEnumCancelled'.

/Since: 2.34/
-}
resolverLookupRecords ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> T.Text
    {- ^ /@rrname@/: the DNS name to look up the record for -}
    -> Gio.Enums.ResolverRecordType
    {- ^ /@recordType@/: the type of DNS record to look up -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> m [GVariant]
    {- ^ __Returns:__ a non-empty 'GI.GLib.Structs.List.List' of
'GVariant', or 'Nothing' on error. You must free each of the records and the list
when you are done with it. (You can use @/g_list_free_full()/@ with
'GI.GLib.Structs.Variant.variantUnref' to do this.) /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupRecords :: a -> Text -> ResolverRecordType -> Maybe b -> m [GVariant]
resolverLookupRecords resolver :: a
resolver rrname :: Text
rrname recordType :: ResolverRecordType
recordType cancellable :: Maybe b
cancellable = IO [GVariant] -> m [GVariant]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [GVariant] -> m [GVariant]) -> IO [GVariant] -> m [GVariant]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    CString
rrname' <- Text -> IO CString
textToCString Text
rrname
    let recordType' :: CUInt
recordType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (ResolverRecordType -> Int) -> ResolverRecordType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverRecordType -> Int
forall a. Enum a => a -> Int
fromEnum) ResolverRecordType
recordType
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO [GVariant] -> ResolverReloadCallback -> IO [GVariant]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr GVariant))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr GVariant))))
-> IO (Ptr (GList (Ptr GVariant)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr GVariant))))
 -> IO (Ptr (GList (Ptr GVariant))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr GVariant))))
-> IO (Ptr (GList (Ptr GVariant)))
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> CString
-> CUInt
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr GVariant)))
g_resolver_lookup_records Ptr Resolver
resolver' CString
rrname' CUInt
recordType' Ptr Cancellable
maybeCancellable
        [Ptr GVariant]
result' <- Ptr (GList (Ptr GVariant)) -> IO [Ptr GVariant]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr GVariant))
result
        [GVariant]
result'' <- (Ptr GVariant -> IO GVariant) -> [Ptr GVariant] -> IO [GVariant]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr [Ptr GVariant]
result'
        Ptr (GList (Ptr GVariant)) -> ResolverReloadCallback
forall a. Ptr (GList a) -> ResolverReloadCallback
g_list_free Ptr (GList (Ptr GVariant))
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        Maybe b -> (b -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
rrname'
        [GVariant] -> IO [GVariant]
forall (m :: * -> *) a. Monad m => a -> m a
return [GVariant]
result''
     ) (do
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
rrname'
     )

#if ENABLE_OVERLOADING
data ResolverLookupRecordsMethodInfo
instance (signature ~ (T.Text -> Gio.Enums.ResolverRecordType -> Maybe (b) -> m [GVariant]), MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo ResolverLookupRecordsMethodInfo a signature where
    overloadedMethod _ = resolverLookupRecords

#endif

-- method Resolver::lookup_records_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "rrname", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the DNS name to look up the record for", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "record_type", argType = TInterface (Name {namespace = "Gio", name = "ResolverRecordType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of DNS record to look up", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call after resolution completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 5, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_resolver_lookup_records_async" g_resolver_lookup_records_async :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    CString ->                              -- rrname : TBasicType TUTF8
    CUInt ->                                -- record_type : TInterface (Name {namespace = "Gio", name = "ResolverRecordType"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Begins asynchronously performing a DNS lookup for the given
/@rrname@/, and eventually calls /@callback@/, which must call
'GI.Gio.Objects.Resolver.resolverLookupRecordsFinish' to get the final result. See
'GI.Gio.Objects.Resolver.resolverLookupRecords' for more details.

/Since: 2.34/
-}
resolverLookupRecordsAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> T.Text
    {- ^ /@rrname@/: the DNS name to look up the record for -}
    -> Gio.Enums.ResolverRecordType
    {- ^ /@recordType@/: the type of DNS record to look up -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: callback to call after resolution completes -}
    -> m ()
resolverLookupRecordsAsync :: a
-> Text
-> ResolverRecordType
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
resolverLookupRecordsAsync resolver :: a
resolver rrname :: Text
rrname recordType :: ResolverRecordType
recordType cancellable :: Maybe b
cancellable callback :: Maybe AsyncReadyCallback
callback = ResolverReloadCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ResolverReloadCallback -> m ()) -> ResolverReloadCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    CString
rrname' <- Text -> IO CString
textToCString Text
rrname
    let recordType' :: CUInt
recordType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (ResolverRecordType -> Int) -> ResolverRecordType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ResolverRecordType -> Int
forall a. Enum a => a -> Int
fromEnum) ResolverRecordType
recordType
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> ResolverReloadCallback
forall a. Storable a => Ptr a -> a -> ResolverReloadCallback
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Resolver
-> CString
-> CUInt
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> ResolverReloadCallback
g_resolver_lookup_records_async Ptr Resolver
resolver' CString
rrname' CUInt
recordType' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
    Maybe b -> (b -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
    CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
rrname'
    () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data ResolverLookupRecordsAsyncMethodInfo
instance (signature ~ (T.Text -> Gio.Enums.ResolverRecordType -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo ResolverLookupRecordsAsyncMethodInfo a signature where
    overloadedMethod _ = resolverLookupRecordsAsync

#endif

-- method Resolver::lookup_records_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the result passed to your #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList TVariant)
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_records_finish" g_resolver_lookup_records_finish :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr GVariant)))

{- |
Retrieves the result of a previous call to
'GI.Gio.Objects.Resolver.resolverLookupRecordsAsync'. Returns a non-empty list of records as
'GVariant' tuples. See 'GI.Gio.Enums.ResolverRecordType' for information on what the
records contain.

If the DNS resolution failed, /@error@/ (if non-'Nothing') will be set to
a value from 'GI.Gio.Enums.ResolverError'. If the operation was cancelled,
/@error@/ will be set to 'GI.Gio.Enums.IOErrorEnumCancelled'.

/Since: 2.34/
-}
resolverLookupRecordsFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> b
    {- ^ /@result@/: the result passed to your 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m [GVariant]
    {- ^ __Returns:__ a non-empty 'GI.GLib.Structs.List.List' of
'GVariant', or 'Nothing' on error. You must free each of the records and the list
when you are done with it. (You can use @/g_list_free_full()/@ with
'GI.GLib.Structs.Variant.variantUnref' to do this.) /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupRecordsFinish :: a -> b -> m [GVariant]
resolverLookupRecordsFinish resolver :: a
resolver result_ :: b
result_ = IO [GVariant] -> m [GVariant]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [GVariant] -> m [GVariant]) -> IO [GVariant] -> m [GVariant]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO [GVariant] -> ResolverReloadCallback -> IO [GVariant]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr GVariant))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr GVariant))))
-> IO (Ptr (GList (Ptr GVariant)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr GVariant))))
 -> IO (Ptr (GList (Ptr GVariant))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr GVariant))))
-> IO (Ptr (GList (Ptr GVariant)))
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> Ptr AsyncResult
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr GVariant)))
g_resolver_lookup_records_finish Ptr Resolver
resolver' Ptr AsyncResult
result_'
        [Ptr GVariant]
result' <- Ptr (GList (Ptr GVariant)) -> IO [Ptr GVariant]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr GVariant))
result
        [GVariant]
result'' <- (Ptr GVariant -> IO GVariant) -> [Ptr GVariant] -> IO [GVariant]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr [Ptr GVariant]
result'
        Ptr (GList (Ptr GVariant)) -> ResolverReloadCallback
forall a. Ptr (GList a) -> ResolverReloadCallback
g_list_free Ptr (GList (Ptr GVariant))
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr b
result_
        [GVariant] -> IO [GVariant]
forall (m :: * -> *) a. Monad m => a -> m a
return [GVariant]
result''
     ) (do
        () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data ResolverLookupRecordsFinishMethodInfo
instance (signature ~ (b -> m [GVariant]), MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo ResolverLookupRecordsFinishMethodInfo a signature where
    overloadedMethod _ = resolverLookupRecordsFinish

#endif

-- method Resolver::lookup_service
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the service type to look up (eg, \"ldap\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the networking protocol to use for @service (eg, \"tcp\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the DNS domain to look up the service in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "SrvTarget"})))
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_service" g_resolver_lookup_service :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    CString ->                              -- service : TBasicType TUTF8
    CString ->                              -- protocol : TBasicType TUTF8
    CString ->                              -- domain : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr Gio.SrvTarget.SrvTarget)))

{- |
Synchronously performs a DNS SRV lookup for the given /@service@/ and
/@protocol@/ in the given /@domain@/ and returns an array of 'GI.Gio.Structs.SrvTarget.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, 'GI.Gio.Objects.Resolver.resolverLookupService' will return a non-empty 'GI.GLib.Structs.List.List' of
'GI.Gio.Structs.SrvTarget.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-'Nothing') will be set to
a value from 'GI.Gio.Enums.ResolverError' and 'Nothing' will be returned.

If /@cancellable@/ is non-'Nothing', it can be used to cancel the
operation, in which case /@error@/ (if non-'Nothing') will be set to
'GI.Gio.Enums.IOErrorEnumCancelled'.

If you are planning to connect to the service, it is usually easier
to create a 'GI.Gio.Objects.NetworkService.NetworkService' and use its 'GI.Gio.Interfaces.SocketConnectable.SocketConnectable'
interface.

/Since: 2.22/
-}
resolverLookupService ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> T.Text
    {- ^ /@service@/: the service type to look up (eg, \"ldap\") -}
    -> T.Text
    {- ^ /@protocol@/: the networking protocol to use for /@service@/ (eg, \"tcp\") -}
    -> T.Text
    {- ^ /@domain@/: the DNS domain to look up the service in -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> m [Gio.SrvTarget.SrvTarget]
    {- ^ __Returns:__ a non-empty 'GI.GLib.Structs.List.List' of
'GI.Gio.Structs.SrvTarget.SrvTarget', or 'Nothing' on error. You must free each of the targets and the
list when you are done with it. (You can use @/g_resolver_free_targets()/@ to do
this.) /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupService :: a -> Text -> Text -> Text -> Maybe b -> m [SrvTarget]
resolverLookupService resolver :: a
resolver service :: Text
service protocol :: Text
protocol domain :: Text
domain cancellable :: Maybe b
cancellable = IO [SrvTarget] -> m [SrvTarget]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [SrvTarget] -> m [SrvTarget])
-> IO [SrvTarget] -> m [SrvTarget]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    CString
service' <- Text -> IO CString
textToCString Text
service
    CString
protocol' <- Text -> IO CString
textToCString Text
protocol
    CString
domain' <- Text -> IO CString
textToCString Text
domain
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    IO [SrvTarget] -> ResolverReloadCallback -> IO [SrvTarget]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr SrvTarget))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr SrvTarget))))
-> IO (Ptr (GList (Ptr SrvTarget)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr SrvTarget))))
 -> IO (Ptr (GList (Ptr SrvTarget))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr SrvTarget))))
-> IO (Ptr (GList (Ptr SrvTarget)))
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> CString
-> CString
-> CString
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr SrvTarget)))
g_resolver_lookup_service Ptr Resolver
resolver' CString
service' CString
protocol' CString
domain' Ptr Cancellable
maybeCancellable
        [Ptr SrvTarget]
result' <- Ptr (GList (Ptr SrvTarget)) -> IO [Ptr SrvTarget]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr SrvTarget))
result
        [SrvTarget]
result'' <- (Ptr SrvTarget -> IO SrvTarget)
-> [Ptr SrvTarget] -> IO [SrvTarget]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr SrvTarget -> SrvTarget)
-> Ptr SrvTarget -> IO SrvTarget
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SrvTarget -> SrvTarget
Gio.SrvTarget.SrvTarget) [Ptr SrvTarget]
result'
        Ptr (GList (Ptr SrvTarget)) -> ResolverReloadCallback
forall a. Ptr (GList a) -> ResolverReloadCallback
g_list_free Ptr (GList (Ptr SrvTarget))
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        Maybe b -> (b -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
service'
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
protocol'
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
domain'
        [SrvTarget] -> IO [SrvTarget]
forall (m :: * -> *) a. Monad m => a -> m a
return [SrvTarget]
result''
     ) (do
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
service'
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
protocol'
        CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
domain'
     )

#if ENABLE_OVERLOADING
data ResolverLookupServiceMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> Maybe (b) -> m [Gio.SrvTarget.SrvTarget]), MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo ResolverLookupServiceMethodInfo a signature where
    overloadedMethod _ = resolverLookupService

#endif

-- method Resolver::lookup_service_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "service", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the service type to look up (eg, \"ldap\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the networking protocol to use for @service (eg, \"tcp\")", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "domain", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the DNS domain to look up the service in", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call after resolution completes", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "data for @callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_resolver_lookup_service_async" g_resolver_lookup_service_async :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    CString ->                              -- service : TBasicType TUTF8
    CString ->                              -- protocol : TBasicType TUTF8
    CString ->                              -- domain : TBasicType TUTF8
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Begins asynchronously performing a DNS SRV lookup for the given
/@service@/ and /@protocol@/ in the given /@domain@/, and eventually calls
/@callback@/, which must call 'GI.Gio.Objects.Resolver.resolverLookupServiceFinish' to
get the final result. See 'GI.Gio.Objects.Resolver.resolverLookupService' for more
details.

/Since: 2.22/
-}
resolverLookupServiceAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> T.Text
    {- ^ /@service@/: the service type to look up (eg, \"ldap\") -}
    -> T.Text
    {- ^ /@protocol@/: the networking protocol to use for /@service@/ (eg, \"tcp\") -}
    -> T.Text
    {- ^ /@domain@/: the DNS domain to look up the service in -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: callback to call after resolution completes -}
    -> m ()
resolverLookupServiceAsync :: a
-> Text
-> Text
-> Text
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
resolverLookupServiceAsync resolver :: a
resolver service :: Text
service protocol :: Text
protocol domain :: Text
domain cancellable :: Maybe b
cancellable callback :: Maybe AsyncReadyCallback
callback = ResolverReloadCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ResolverReloadCallback -> m ()) -> ResolverReloadCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    CString
service' <- Text -> IO CString
textToCString Text
service
    CString
protocol' <- Text -> IO CString
textToCString Text
protocol
    CString
domain' <- Text -> IO CString
textToCString Text
domain
    Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
        Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
        Just jCancellable :: b
jCancellable -> do
            Ptr Cancellable
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
            Ptr Cancellable -> IO (Ptr Cancellable)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just jCallback :: AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> ResolverReloadCallback
forall a. Storable a => Ptr a -> a -> ResolverReloadCallback
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
    Ptr Resolver
-> CString
-> CString
-> CString
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> ResolverReloadCallback
g_resolver_lookup_service_async Ptr Resolver
resolver' CString
service' CString
protocol' CString
domain' Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
userData
    a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
    Maybe b -> (b -> ResolverReloadCallback) -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr
    CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
service'
    CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
protocol'
    CString -> ResolverReloadCallback
forall a. Ptr a -> ResolverReloadCallback
freeMem CString
domain'
    () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data ResolverLookupServiceAsyncMethodInfo
instance (signature ~ (T.Text -> T.Text -> T.Text -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsResolver a, Gio.Cancellable.IsCancellable b) => O.MethodInfo ResolverLookupServiceAsyncMethodInfo a signature where
    overloadedMethod _ = resolverLookupServiceAsync

#endif

-- method Resolver::lookup_service_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the result passed to your #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TGList (TInterface (Name {namespace = "Gio", name = "SrvTarget"})))
-- throws : True
-- Skip return : False

foreign import ccall "g_resolver_lookup_service_finish" g_resolver_lookup_service_finish :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr (GList (Ptr Gio.SrvTarget.SrvTarget)))

{- |
Retrieves the result of a previous call to
'GI.Gio.Objects.Resolver.resolverLookupServiceAsync'.

If the DNS resolution failed, /@error@/ (if non-'Nothing') will be set to
a value from 'GI.Gio.Enums.ResolverError'. If the operation was cancelled,
/@error@/ will be set to 'GI.Gio.Enums.IOErrorEnumCancelled'.

/Since: 2.22/
-}
resolverLookupServiceFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@resolver@/: a 'GI.Gio.Objects.Resolver.Resolver' -}
    -> b
    {- ^ /@result@/: the result passed to your 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m [Gio.SrvTarget.SrvTarget]
    {- ^ __Returns:__ a non-empty 'GI.GLib.Structs.List.List' of
'GI.Gio.Structs.SrvTarget.SrvTarget', or 'Nothing' on error. See 'GI.Gio.Objects.Resolver.resolverLookupService' for more
details. /(Can throw 'Data.GI.Base.GError.GError')/ -}
resolverLookupServiceFinish :: a -> b -> m [SrvTarget]
resolverLookupServiceFinish resolver :: a
resolver result_ :: b
result_ = IO [SrvTarget] -> m [SrvTarget]
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [SrvTarget] -> m [SrvTarget])
-> IO [SrvTarget] -> m [SrvTarget]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO [SrvTarget] -> ResolverReloadCallback -> IO [SrvTarget]
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr (GList (Ptr SrvTarget))
result <- (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr SrvTarget))))
-> IO (Ptr (GList (Ptr SrvTarget)))
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr (GList (Ptr SrvTarget))))
 -> IO (Ptr (GList (Ptr SrvTarget))))
-> (Ptr (Ptr GError) -> IO (Ptr (GList (Ptr SrvTarget))))
-> IO (Ptr (GList (Ptr SrvTarget)))
forall a b. (a -> b) -> a -> b
$ Ptr Resolver
-> Ptr AsyncResult
-> Ptr (Ptr GError)
-> IO (Ptr (GList (Ptr SrvTarget)))
g_resolver_lookup_service_finish Ptr Resolver
resolver' Ptr AsyncResult
result_'
        [Ptr SrvTarget]
result' <- Ptr (GList (Ptr SrvTarget)) -> IO [Ptr SrvTarget]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr SrvTarget))
result
        [SrvTarget]
result'' <- (Ptr SrvTarget -> IO SrvTarget)
-> [Ptr SrvTarget] -> IO [SrvTarget]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr SrvTarget -> SrvTarget)
-> Ptr SrvTarget -> IO SrvTarget
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SrvTarget -> SrvTarget
Gio.SrvTarget.SrvTarget) [Ptr SrvTarget]
result'
        Ptr (GList (Ptr SrvTarget)) -> ResolverReloadCallback
forall a. Ptr (GList a) -> ResolverReloadCallback
g_list_free Ptr (GList (Ptr SrvTarget))
result
        a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
        b -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr b
result_
        [SrvTarget] -> IO [SrvTarget]
forall (m :: * -> *) a. Monad m => a -> m a
return [SrvTarget]
result''
     ) (do
        () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if ENABLE_OVERLOADING
data ResolverLookupServiceFinishMethodInfo
instance (signature ~ (b -> m [Gio.SrvTarget.SrvTarget]), MonadIO m, IsResolver a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo ResolverLookupServiceFinishMethodInfo a signature where
    overloadedMethod _ = resolverLookupServiceFinish

#endif

-- method Resolver::set_default
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "resolver", argType = TInterface (Name {namespace = "Gio", name = "Resolver"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the new default #GResolver", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_resolver_set_default" g_resolver_set_default :: 
    Ptr Resolver ->                         -- resolver : TInterface (Name {namespace = "Gio", name = "Resolver"})
    IO ()

{- |
Sets /@resolver@/ to be the application\'s default resolver (reffing
/@resolver@/, and unreffing the previous default resolver, if any).
Future calls to 'GI.Gio.Objects.Resolver.resolverGetDefault' 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 'GI.Gio.Objects.Resolver.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.

/Since: 2.22/
-}
resolverSetDefault ::
    (B.CallStack.HasCallStack, MonadIO m, IsResolver a) =>
    a
    {- ^ /@resolver@/: the new default 'GI.Gio.Objects.Resolver.Resolver' -}
    -> m ()
resolverSetDefault :: a -> m ()
resolverSetDefault resolver :: a
resolver = ResolverReloadCallback -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (ResolverReloadCallback -> m ()) -> ResolverReloadCallback -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
resolver' <- a -> IO (Ptr Resolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
resolver
    Ptr Resolver -> ResolverReloadCallback
g_resolver_set_default Ptr Resolver
resolver'
    a -> ResolverReloadCallback
forall a. ManagedPtrNewtype a => a -> ResolverReloadCallback
touchManagedPtr a
resolver
    () -> ResolverReloadCallback
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if ENABLE_OVERLOADING
data ResolverSetDefaultMethodInfo
instance (signature ~ (m ()), MonadIO m, IsResolver a) => O.MethodInfo ResolverSetDefaultMethodInfo a signature where
    overloadedMethod _ = resolverSetDefault

#endif

-- method Resolver::get_default
-- method type : MemberFunction
-- Args : []
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "Resolver"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_resolver_get_default" g_resolver_get_default :: 
    IO (Ptr Resolver)

{- |
Gets the default 'GI.Gio.Objects.Resolver.Resolver'. You should unref it when you are done
with it. 'GI.Gio.Objects.Resolver.Resolver' may use its reference count as a hint about how
many threads it should allocate for concurrent DNS resolutions.

/Since: 2.22/
-}
resolverGetDefault ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Resolver
    {- ^ __Returns:__ the default 'GI.Gio.Objects.Resolver.Resolver'. -}
resolverGetDefault :: m Resolver
resolverGetDefault  = IO Resolver -> m Resolver
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Resolver -> m Resolver) -> IO Resolver -> m Resolver
forall a b. (a -> b) -> a -> b
$ do
    Ptr Resolver
result <- IO (Ptr Resolver)
g_resolver_get_default
    Text -> Ptr Resolver -> ResolverReloadCallback
forall a. HasCallStack => Text -> Ptr a -> ResolverReloadCallback
checkUnexpectedReturnNULL "resolverGetDefault" Ptr Resolver
result
    Resolver
result' <- ((ManagedPtr Resolver -> Resolver) -> Ptr Resolver -> IO Resolver
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Resolver -> Resolver
Resolver) Ptr Resolver
result
    Resolver -> IO Resolver
forall (m :: * -> *) a. Monad m => a -> m a
return Resolver
result'

#if ENABLE_OVERLOADING
#endif