{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Interfaces.ProxyURIResolver
(
ProxyURIResolver(..) ,
IsProxyURIResolver ,
toProxyURIResolver ,
#if defined(ENABLE_OVERLOADING)
ResolveProxyURIResolverMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
ProxyURIResolverGetProxyUriAsyncMethodInfo,
#endif
proxyURIResolverGetProxyUriAsync ,
#if defined(ENABLE_OVERLOADING)
ProxyURIResolverGetProxyUriSyncMethodInfo,
#endif
proxyURIResolverGetProxyUriSync ,
) 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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GLib.Structs.MainContext as GLib.MainContext
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Soup.Callbacks as Soup.Callbacks
import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature
import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI
newtype ProxyURIResolver = ProxyURIResolver (SP.ManagedPtr ProxyURIResolver)
deriving (ProxyURIResolver -> ProxyURIResolver -> Bool
(ProxyURIResolver -> ProxyURIResolver -> Bool)
-> (ProxyURIResolver -> ProxyURIResolver -> Bool)
-> Eq ProxyURIResolver
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProxyURIResolver -> ProxyURIResolver -> Bool
== :: ProxyURIResolver -> ProxyURIResolver -> Bool
$c/= :: ProxyURIResolver -> ProxyURIResolver -> Bool
/= :: ProxyURIResolver -> ProxyURIResolver -> Bool
Eq)
instance SP.ManagedPtrNewtype ProxyURIResolver where
toManagedPtr :: ProxyURIResolver -> ManagedPtr ProxyURIResolver
toManagedPtr (ProxyURIResolver ManagedPtr ProxyURIResolver
p) = ManagedPtr ProxyURIResolver
p
foreign import ccall "soup_proxy_uri_resolver_get_type"
c_soup_proxy_uri_resolver_get_type :: IO B.Types.GType
instance B.Types.TypedObject ProxyURIResolver where
glibType :: IO GType
glibType = IO GType
c_soup_proxy_uri_resolver_get_type
instance B.Types.GObject ProxyURIResolver
class (SP.GObject o, O.IsDescendantOf ProxyURIResolver o) => IsProxyURIResolver o
instance (SP.GObject o, O.IsDescendantOf ProxyURIResolver o) => IsProxyURIResolver o
instance O.HasParentTypes ProxyURIResolver
type instance O.ParentTypes ProxyURIResolver = '[Soup.SessionFeature.SessionFeature, GObject.Object.Object]
toProxyURIResolver :: (MIO.MonadIO m, IsProxyURIResolver o) => o -> m ProxyURIResolver
toProxyURIResolver :: forall (m :: * -> *) o.
(MonadIO m, IsProxyURIResolver o) =>
o -> m ProxyURIResolver
toProxyURIResolver = IO ProxyURIResolver -> m ProxyURIResolver
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ProxyURIResolver -> m ProxyURIResolver)
-> (o -> IO ProxyURIResolver) -> o -> m ProxyURIResolver
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ProxyURIResolver -> ProxyURIResolver)
-> o -> IO ProxyURIResolver
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ProxyURIResolver -> ProxyURIResolver
ProxyURIResolver
instance B.GValue.IsGValue (Maybe ProxyURIResolver) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_proxy_uri_resolver_get_type
gvalueSet_ :: Ptr GValue -> Maybe ProxyURIResolver -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ProxyURIResolver
P.Nothing = Ptr GValue -> Ptr ProxyURIResolver -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ProxyURIResolver
forall a. Ptr a
FP.nullPtr :: FP.Ptr ProxyURIResolver)
gvalueSet_ Ptr GValue
gv (P.Just ProxyURIResolver
obj) = ProxyURIResolver -> (Ptr ProxyURIResolver -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ProxyURIResolver
obj (Ptr GValue -> Ptr ProxyURIResolver -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe ProxyURIResolver)
gvalueGet_ Ptr GValue
gv = do
Ptr ProxyURIResolver
ptr <- Ptr GValue -> IO (Ptr ProxyURIResolver)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ProxyURIResolver)
if Ptr ProxyURIResolver
ptr Ptr ProxyURIResolver -> Ptr ProxyURIResolver -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ProxyURIResolver
forall a. Ptr a
FP.nullPtr
then ProxyURIResolver -> Maybe ProxyURIResolver
forall a. a -> Maybe a
P.Just (ProxyURIResolver -> Maybe ProxyURIResolver)
-> IO ProxyURIResolver -> IO (Maybe ProxyURIResolver)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ProxyURIResolver -> ProxyURIResolver)
-> Ptr ProxyURIResolver -> IO ProxyURIResolver
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ProxyURIResolver -> ProxyURIResolver
ProxyURIResolver Ptr ProxyURIResolver
ptr
else Maybe ProxyURIResolver -> IO (Maybe ProxyURIResolver)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ProxyURIResolver
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ProxyURIResolver
type instance O.AttributeList ProxyURIResolver = ProxyURIResolverAttributeList
type ProxyURIResolverAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveProxyURIResolverMethod (t :: Symbol) (o :: *) :: * where
ResolveProxyURIResolverMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo
ResolveProxyURIResolverMethod "attach" o = Soup.SessionFeature.SessionFeatureAttachMethodInfo
ResolveProxyURIResolverMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveProxyURIResolverMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveProxyURIResolverMethod "detach" o = Soup.SessionFeature.SessionFeatureDetachMethodInfo
ResolveProxyURIResolverMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveProxyURIResolverMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveProxyURIResolverMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveProxyURIResolverMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo
ResolveProxyURIResolverMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveProxyURIResolverMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveProxyURIResolverMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveProxyURIResolverMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveProxyURIResolverMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveProxyURIResolverMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo
ResolveProxyURIResolverMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveProxyURIResolverMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveProxyURIResolverMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveProxyURIResolverMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveProxyURIResolverMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveProxyURIResolverMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveProxyURIResolverMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveProxyURIResolverMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveProxyURIResolverMethod "getProxyUriAsync" o = ProxyURIResolverGetProxyUriAsyncMethodInfo
ResolveProxyURIResolverMethod "getProxyUriSync" o = ProxyURIResolverGetProxyUriSyncMethodInfo
ResolveProxyURIResolverMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveProxyURIResolverMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveProxyURIResolverMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveProxyURIResolverMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveProxyURIResolverMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveProxyURIResolverMethod t ProxyURIResolver, O.OverloadedMethod info ProxyURIResolver p) => OL.IsLabel t (ProxyURIResolver -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveProxyURIResolverMethod t ProxyURIResolver, O.OverloadedMethod info ProxyURIResolver p, R.HasField t ProxyURIResolver p) => R.HasField t ProxyURIResolver p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveProxyURIResolverMethod t ProxyURIResolver, O.OverloadedMethodInfo info ProxyURIResolver) => OL.IsLabel t (O.MethodProxy info ProxyURIResolver) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
foreign import ccall "soup_proxy_uri_resolver_get_proxy_uri_async" soup_proxy_uri_resolver_get_proxy_uri_async ::
Ptr ProxyURIResolver ->
Ptr Soup.URI.URI ->
Ptr GLib.MainContext.MainContext ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Soup.Callbacks.C_ProxyURIResolverCallback ->
Ptr () ->
IO ()
{-# DEPRECATED proxyURIResolverGetProxyUriAsync ["t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver' is deprecated in favor of","t'GI.Gio.Interfaces.ProxyResolver.ProxyResolver'"] #-}
proxyURIResolverGetProxyUriAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsProxyURIResolver a, Gio.Cancellable.IsCancellable b) =>
a
-> Soup.URI.URI
-> Maybe (GLib.MainContext.MainContext)
-> Maybe (b)
-> Soup.Callbacks.ProxyURIResolverCallback
-> m ()
proxyURIResolverGetProxyUriAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsProxyURIResolver a, IsCancellable b) =>
a
-> URI
-> Maybe MainContext
-> Maybe b
-> ProxyURIResolverCallback
-> m ()
proxyURIResolverGetProxyUriAsync a
proxyUriResolver URI
uri Maybe MainContext
asyncContext Maybe b
cancellable ProxyURIResolverCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr ProxyURIResolver
proxyUriResolver' <- a -> IO (Ptr ProxyURIResolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
proxyUriResolver
Ptr URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
Ptr MainContext
maybeAsyncContext <- case Maybe MainContext
asyncContext of
Maybe MainContext
Nothing -> Ptr MainContext -> IO (Ptr MainContext)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MainContext
forall a. Ptr a
nullPtr
Just MainContext
jAsyncContext -> do
Ptr MainContext
jAsyncContext' <- MainContext -> IO (Ptr MainContext)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MainContext
jAsyncContext
Ptr MainContext -> IO (Ptr MainContext)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr MainContext
jAsyncContext'
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
Just 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
Ptr (FunPtr C_ProxyURIResolverCallback)
ptrcallback <- IO (Ptr (FunPtr C_ProxyURIResolverCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Soup.Callbacks.C_ProxyURIResolverCallback))
FunPtr C_ProxyURIResolverCallback
callback' <- C_ProxyURIResolverCallback
-> IO (FunPtr C_ProxyURIResolverCallback)
Soup.Callbacks.mk_ProxyURIResolverCallback (Maybe (Ptr (FunPtr C_ProxyURIResolverCallback))
-> ProxyURIResolverCallback_WithClosures
-> C_ProxyURIResolverCallback
Soup.Callbacks.wrap_ProxyURIResolverCallback (Ptr (FunPtr C_ProxyURIResolverCallback)
-> Maybe (Ptr (FunPtr C_ProxyURIResolverCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_ProxyURIResolverCallback)
ptrcallback) (ProxyURIResolverCallback -> ProxyURIResolverCallback_WithClosures
Soup.Callbacks.drop_closures_ProxyURIResolverCallback ProxyURIResolverCallback
callback))
Ptr (FunPtr C_ProxyURIResolverCallback)
-> FunPtr C_ProxyURIResolverCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_ProxyURIResolverCallback)
ptrcallback FunPtr C_ProxyURIResolverCallback
callback'
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr ProxyURIResolver
-> Ptr URI
-> Ptr MainContext
-> Ptr Cancellable
-> FunPtr C_ProxyURIResolverCallback
-> Ptr ()
-> IO ()
soup_proxy_uri_resolver_get_proxy_uri_async Ptr ProxyURIResolver
proxyUriResolver' Ptr URI
uri' Ptr MainContext
maybeAsyncContext Ptr Cancellable
maybeCancellable FunPtr C_ProxyURIResolverCallback
callback' Ptr ()
forall a. Ptr a
userData
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
proxyUriResolver
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Maybe MainContext -> (MainContext -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe MainContext
asyncContext MainContext -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data ProxyURIResolverGetProxyUriAsyncMethodInfo
instance (signature ~ (Soup.URI.URI -> Maybe (GLib.MainContext.MainContext) -> Maybe (b) -> Soup.Callbacks.ProxyURIResolverCallback -> m ()), MonadIO m, IsProxyURIResolver a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod ProxyURIResolverGetProxyUriAsyncMethodInfo a signature where
overloadedMethod = proxyURIResolverGetProxyUriAsync
instance O.OverloadedMethodInfo ProxyURIResolverGetProxyUriAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Interfaces.ProxyURIResolver.proxyURIResolverGetProxyUriAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Interfaces-ProxyURIResolver.html#v:proxyURIResolverGetProxyUriAsync"
})
#endif
foreign import ccall "soup_proxy_uri_resolver_get_proxy_uri_sync" soup_proxy_uri_resolver_get_proxy_uri_sync ::
Ptr ProxyURIResolver ->
Ptr Soup.URI.URI ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr Soup.URI.URI) ->
IO Word32
{-# DEPRECATED proxyURIResolverGetProxyUriSync ["t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver' is deprecated in favor of","t'GI.Gio.Interfaces.ProxyResolver.ProxyResolver'"] #-}
proxyURIResolverGetProxyUriSync ::
(B.CallStack.HasCallStack, MonadIO m, IsProxyURIResolver a, Gio.Cancellable.IsCancellable b) =>
a
-> Soup.URI.URI
-> Maybe (b)
-> m ((Word32, Soup.URI.URI))
proxyURIResolverGetProxyUriSync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsProxyURIResolver a, IsCancellable b) =>
a -> URI -> Maybe b -> m (Word32, URI)
proxyURIResolverGetProxyUriSync a
proxyUriResolver URI
uri Maybe b
cancellable = IO (Word32, URI) -> m (Word32, URI)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word32, URI) -> m (Word32, URI))
-> IO (Word32, URI) -> m (Word32, URI)
forall a b. (a -> b) -> a -> b
$ do
Ptr ProxyURIResolver
proxyUriResolver' <- a -> IO (Ptr ProxyURIResolver)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
proxyUriResolver
Ptr URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
nullPtr
Just 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 a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
Ptr (Ptr URI)
proxyUri <- IO (Ptr (Ptr URI))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Soup.URI.URI))
Word32
result <- Ptr ProxyURIResolver
-> Ptr URI -> Ptr Cancellable -> Ptr (Ptr URI) -> IO Word32
soup_proxy_uri_resolver_get_proxy_uri_sync Ptr ProxyURIResolver
proxyUriResolver' Ptr URI
uri' Ptr Cancellable
maybeCancellable Ptr (Ptr URI)
proxyUri
Ptr URI
proxyUri' <- Ptr (Ptr URI) -> IO (Ptr URI)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr URI)
proxyUri
URI
proxyUri'' <- ((ManagedPtr URI -> URI) -> Ptr URI -> IO URI
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr URI -> URI
Soup.URI.URI) Ptr URI
proxyUri'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
proxyUriResolver
URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
Maybe b -> (b -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
Ptr (Ptr URI) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr URI)
proxyUri
(Word32, URI) -> IO (Word32, URI)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32
result, URI
proxyUri'')
#if defined(ENABLE_OVERLOADING)
data ProxyURIResolverGetProxyUriSyncMethodInfo
instance (signature ~ (Soup.URI.URI -> Maybe (b) -> m ((Word32, Soup.URI.URI))), MonadIO m, IsProxyURIResolver a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod ProxyURIResolverGetProxyUriSyncMethodInfo a signature where
overloadedMethod = proxyURIResolverGetProxyUriSync
instance O.OverloadedMethodInfo ProxyURIResolverGetProxyUriSyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Interfaces.ProxyURIResolver.proxyURIResolverGetProxyUriSync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Interfaces-ProxyURIResolver.html#v:proxyURIResolverGetProxyUriSync"
})
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ProxyURIResolver = ProxyURIResolverSignalList
type ProxyURIResolverSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif