{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Soup.Interfaces.ProxyURIResolver
    ( 

-- * Exported types
    ProxyURIResolver(..)                    ,
    IsProxyURIResolver                      ,
    toProxyURIResolver                      ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveProxyURIResolverMethod           ,
#endif


-- ** getProxyUriAsync #method:getProxyUriAsync#

#if defined(ENABLE_OVERLOADING)
    ProxyURIResolverGetProxyUriAsyncMethodInfo,
#endif
    proxyURIResolverGetProxyUriAsync        ,


-- ** getProxyUriSync #method:getProxyUriSync#

#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

-- interface ProxyURIResolver 
-- | Memory-managed wrapper type.
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

-- | Convert 'ProxyURIResolver' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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
        
    

-- | Type class for types which can be safely cast to `ProxyURIResolver`, for instance with `toProxyURIResolver`.
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]

-- | Cast to `ProxyURIResolver`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
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

-- method ProxyURIResolver::get_proxy_uri_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "proxy_uri_resolver"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ProxyURIResolver" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupProxyURIResolver"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TInterface Name { namespace = "Soup" , name = "URI" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupURI you want a proxy for"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "async_context"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "MainContext" }
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GMainContext to invoke @callback 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 = "Soup" , name = "ProxyURIResolverCallback" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "callback to invoke with the proxy address"
--                 , 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 "soup_proxy_uri_resolver_get_proxy_uri_async" soup_proxy_uri_resolver_get_proxy_uri_async :: 
    Ptr ProxyURIResolver ->                 -- proxy_uri_resolver : TInterface (Name {namespace = "Soup", name = "ProxyURIResolver"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr GLib.MainContext.MainContext ->     -- async_context : TInterface (Name {namespace = "GLib", name = "MainContext"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Soup.Callbacks.C_ProxyURIResolverCallback -> -- callback : TInterface (Name {namespace = "Soup", name = "ProxyURIResolverCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{-# DEPRECATED proxyURIResolverGetProxyUriAsync ["t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver' is deprecated in favor of","t'GI.Gio.Interfaces.ProxyResolver.ProxyResolver'"] #-}
-- | Asynchronously determines a proxy URI to use for /@msg@/ and calls
-- /@callback@/.
-- 
-- /Since: 2.26.3/
proxyURIResolverGetProxyUriAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsProxyURIResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@proxyUriResolver@/: the t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver'
    -> Soup.URI.URI
    -- ^ /@uri@/: the t'GI.Soup.Structs.URI.URI' you want a proxy for
    -> Maybe (GLib.MainContext.MainContext)
    -- ^ /@asyncContext@/: the t'GI.GLib.Structs.MainContext.MainContext' to invoke /@callback@/ in
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> Soup.Callbacks.ProxyURIResolverCallback
    -- ^ /@callback@/: callback to invoke with the proxy address
    -> 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

-- method ProxyURIResolver::get_proxy_uri_sync
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "proxy_uri_resolver"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ProxyURIResolver" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupProxyURIResolver"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri"
--           , argType = TInterface Name { namespace = "Soup" , name = "URI" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupURI you want a proxy for"
--                 , 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 = "proxy_uri"
--           , argType = TInterface Name { namespace = "Soup" , name = "URI" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "on return, will contain the proxy URI"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_proxy_uri_resolver_get_proxy_uri_sync" soup_proxy_uri_resolver_get_proxy_uri_sync :: 
    Ptr ProxyURIResolver ->                 -- proxy_uri_resolver : TInterface (Name {namespace = "Soup", name = "ProxyURIResolver"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr Soup.URI.URI) ->               -- proxy_uri : TInterface (Name {namespace = "Soup", name = "URI"})
    IO Word32

{-# DEPRECATED proxyURIResolverGetProxyUriSync ["t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver' is deprecated in favor of","t'GI.Gio.Interfaces.ProxyResolver.ProxyResolver'"] #-}
-- | Synchronously determines a proxy URI to use for /@uri@/. If /@uri@/
-- should be sent via proxy, */@proxyUri@/ will be set to the URI of the
-- proxy, else it will be set to 'P.Nothing'.
-- 
-- /Since: 2.26.3/
proxyURIResolverGetProxyUriSync ::
    (B.CallStack.HasCallStack, MonadIO m, IsProxyURIResolver a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@proxyUriResolver@/: the t'GI.Soup.Interfaces.ProxyURIResolver.ProxyURIResolver'
    -> Soup.URI.URI
    -- ^ /@uri@/: the t'GI.Soup.Structs.URI.URI' you want a proxy for
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable', or 'P.Nothing'
    -> m ((Word32, Soup.URI.URI))
    -- ^ __Returns:__ 'GI.Soup.Enums.StatusOk' if successful, or a transport-level
    -- error.
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