#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Soup.Interfaces.ProxyURIResolver
(
ProxyURIResolver(..) ,
noProxyURIResolver ,
IsProxyURIResolver ,
toProxyURIResolver ,
#if ENABLE_OVERLOADING
ProxyURIResolverGetProxyUriAsyncMethodInfo,
#endif
proxyURIResolverGetProxyUriAsync ,
#if 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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
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.GI.Base.Properties as B.Properties
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 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 (ManagedPtr ProxyURIResolver)
noProxyURIResolver :: Maybe ProxyURIResolver
noProxyURIResolver = Nothing
#if ENABLE_OVERLOADING
type instance O.SignalList ProxyURIResolver = ProxyURIResolverSignalList
type ProxyURIResolverSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_proxy_uri_resolver_get_type"
c_soup_proxy_uri_resolver_get_type :: IO GType
instance GObject ProxyURIResolver where
gobjectType = c_soup_proxy_uri_resolver_get_type
class (GObject o, O.IsDescendantOf ProxyURIResolver o) => IsProxyURIResolver o
instance (GObject o, O.IsDescendantOf ProxyURIResolver o) => IsProxyURIResolver o
instance O.HasParentTypes ProxyURIResolver
type instance O.ParentTypes ProxyURIResolver = '[Soup.SessionFeature.SessionFeature, GObject.Object.Object]
toProxyURIResolver :: (MonadIO m, IsProxyURIResolver o) => o -> m ProxyURIResolver
toProxyURIResolver = liftIO . unsafeCastTo ProxyURIResolver
#if ENABLE_OVERLOADING
instance O.HasAttributeList ProxyURIResolver
type instance O.AttributeList ProxyURIResolver = ProxyURIResolverAttributeList
type ProxyURIResolverAttributeList = ('[ ] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
#endif
#if 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.MethodInfo info ProxyURIResolver p) => OL.IsLabel t (ProxyURIResolver -> 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
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 ["'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver' is deprecated in favor of","'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 proxyUriResolver uri asyncContext cancellable callback = liftIO $ do
proxyUriResolver' <- unsafeManagedPtrCastPtr proxyUriResolver
uri' <- unsafeManagedPtrGetPtr uri
maybeAsyncContext <- case asyncContext of
Nothing -> return nullPtr
Just jAsyncContext -> do
jAsyncContext' <- unsafeManagedPtrGetPtr jAsyncContext
return jAsyncContext'
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
ptrcallback <- callocMem :: IO (Ptr (FunPtr Soup.Callbacks.C_ProxyURIResolverCallback))
callback' <- Soup.Callbacks.mk_ProxyURIResolverCallback (Soup.Callbacks.wrap_ProxyURIResolverCallback (Just ptrcallback) (Soup.Callbacks.drop_closures_ProxyURIResolverCallback callback))
poke ptrcallback callback'
let userData = nullPtr
soup_proxy_uri_resolver_get_proxy_uri_async proxyUriResolver' uri' maybeAsyncContext maybeCancellable callback' userData
touchManagedPtr proxyUriResolver
touchManagedPtr uri
whenJust asyncContext touchManagedPtr
whenJust cancellable touchManagedPtr
return ()
#if 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.MethodInfo ProxyURIResolverGetProxyUriAsyncMethodInfo a signature where
overloadedMethod _ = 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 ["'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver' is deprecated in favor of","'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 proxyUriResolver uri cancellable = liftIO $ do
proxyUriResolver' <- unsafeManagedPtrCastPtr proxyUriResolver
uri' <- unsafeManagedPtrGetPtr uri
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
proxyUri <- allocMem :: IO (Ptr (Ptr Soup.URI.URI))
result <- soup_proxy_uri_resolver_get_proxy_uri_sync proxyUriResolver' uri' maybeCancellable proxyUri
proxyUri' <- peek proxyUri
proxyUri'' <- (wrapBoxed Soup.URI.URI) proxyUri'
touchManagedPtr proxyUriResolver
touchManagedPtr uri
whenJust cancellable touchManagedPtr
freeMem proxyUri
return (result, proxyUri'')
#if 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.MethodInfo ProxyURIResolverGetProxyUriSyncMethodInfo a signature where
overloadedMethod _ = proxyURIResolverGetProxyUriSync
#endif