{-# 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.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.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
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 (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
/= :: ProxyURIResolver -> ProxyURIResolver -> Bool
$c/= :: ProxyURIResolver -> ProxyURIResolver -> Bool
== :: ProxyURIResolver -> ProxyURIResolver -> Bool
$c== :: 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
instance B.GValue.IsGValue ProxyURIResolver where
toGValue :: ProxyURIResolver -> IO GValue
toGValue ProxyURIResolver
o = do
GType
gtype <- IO GType
c_soup_proxy_uri_resolver_get_type
ProxyURIResolver
-> (Ptr ProxyURIResolver -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ProxyURIResolver
o (GType
-> (GValue -> Ptr ProxyURIResolver -> IO ())
-> Ptr ProxyURIResolver
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr ProxyURIResolver -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
fromGValue :: GValue -> IO ProxyURIResolver
fromGValue GValue
gv = do
Ptr ProxyURIResolver
ptr <- GValue -> IO (Ptr ProxyURIResolver)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr ProxyURIResolver)
(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
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 :: (MonadIO m, IsProxyURIResolver o) => o -> m ProxyURIResolver
toProxyURIResolver :: o -> m ProxyURIResolver
toProxyURIResolver = IO ProxyURIResolver -> m ProxyURIResolver
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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'
unsafeCastTo ManagedPtr ProxyURIResolver -> ProxyURIResolver
ProxyURIResolver
#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.MethodInfo 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
#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 :: a
-> URI
-> Maybe MainContext
-> Maybe b
-> ProxyURIResolverCallback
-> m ()
proxyURIResolverGetProxyUriAsync a
proxyUriResolver URI
uri Maybe MainContext
asyncContext Maybe b
cancellable ProxyURIResolverCallback
callback = IO () -> m ()
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 (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 (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 (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 (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 (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.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 ["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 :: a -> URI -> Maybe b -> m (Word32, URI)
proxyURIResolverGetProxyUriSync a
proxyUriResolver URI
uri Maybe b
cancellable = IO (Word32, URI) -> m (Word32, URI)
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 (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 (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 (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.MethodInfo ProxyURIResolverGetProxyUriSyncMethodInfo a signature where
overloadedMethod = proxyURIResolverGetProxyUriSync
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ProxyURIResolver = ProxyURIResolverSignalList
type ProxyURIResolverSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif