{-# 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.Objects.Requester
    ( 

-- * Exported types
    Requester(..)                           ,
    IsRequester                             ,
    toRequester                             ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addFeature]("GI.Soup.Interfaces.SessionFeature#g:method:addFeature"), [attach]("GI.Soup.Interfaces.SessionFeature#g:method:attach"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [detach]("GI.Soup.Interfaces.SessionFeature#g:method:detach"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [hasFeature]("GI.Soup.Interfaces.SessionFeature#g:method:hasFeature"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [removeFeature]("GI.Soup.Interfaces.SessionFeature#g:method:removeFeature"), [request]("GI.Soup.Objects.Requester#g:method:request"), [requestUri]("GI.Soup.Objects.Requester#g:method:requestUri"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveRequesterMethod                  ,
#endif

-- ** new #method:new#

    requesterNew                            ,


-- ** request #method:request#

#if defined(ENABLE_OVERLOADING)
    RequesterRequestMethodInfo              ,
#endif
    requesterRequest                        ,


-- ** requestUri #method:requestUri#

#if defined(ENABLE_OVERLOADING)
    RequesterRequestUriMethodInfo           ,
#endif
    requesterRequestUri                     ,




    ) 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.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 GHC.Records as R

import qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Soup.Interfaces.SessionFeature as Soup.SessionFeature
import {-# SOURCE #-} qualified GI.Soup.Objects.Request as Soup.Request
import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI

-- | Memory-managed wrapper type.
newtype Requester = Requester (SP.ManagedPtr Requester)
    deriving (Requester -> Requester -> Bool
(Requester -> Requester -> Bool)
-> (Requester -> Requester -> Bool) -> Eq Requester
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Requester -> Requester -> Bool
$c/= :: Requester -> Requester -> Bool
== :: Requester -> Requester -> Bool
$c== :: Requester -> Requester -> Bool
Eq)

instance SP.ManagedPtrNewtype Requester where
    toManagedPtr :: Requester -> ManagedPtr Requester
toManagedPtr (Requester ManagedPtr Requester
p) = ManagedPtr Requester
p

foreign import ccall "soup_requester_get_type"
    c_soup_requester_get_type :: IO B.Types.GType

instance B.Types.TypedObject Requester where
    glibType :: IO GType
glibType = IO GType
c_soup_requester_get_type

instance B.Types.GObject Requester

-- | Type class for types which can be safely cast to `Requester`, for instance with `toRequester`.
class (SP.GObject o, O.IsDescendantOf Requester o) => IsRequester o
instance (SP.GObject o, O.IsDescendantOf Requester o) => IsRequester o

instance O.HasParentTypes Requester
type instance O.ParentTypes Requester = '[GObject.Object.Object, Soup.SessionFeature.SessionFeature]

-- | Cast to `Requester`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toRequester :: (MIO.MonadIO m, IsRequester o) => o -> m Requester
toRequester :: forall (m :: * -> *) o.
(MonadIO m, IsRequester o) =>
o -> m Requester
toRequester = IO Requester -> m Requester
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Requester -> m Requester)
-> (o -> IO Requester) -> o -> m Requester
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Requester -> Requester) -> o -> IO Requester
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Requester -> Requester
Requester

-- | Convert 'Requester' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe Requester) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_requester_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Requester -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Requester
P.Nothing = Ptr GValue -> Ptr Requester -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Requester
forall a. Ptr a
FP.nullPtr :: FP.Ptr Requester)
    gvalueSet_ Ptr GValue
gv (P.Just Requester
obj) = Requester -> (Ptr Requester -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Requester
obj (Ptr GValue -> Ptr Requester -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Requester)
gvalueGet_ Ptr GValue
gv = do
        Ptr Requester
ptr <- Ptr GValue -> IO (Ptr Requester)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Requester)
        if Ptr Requester
ptr Ptr Requester -> Ptr Requester -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Requester
forall a. Ptr a
FP.nullPtr
        then Requester -> Maybe Requester
forall a. a -> Maybe a
P.Just (Requester -> Maybe Requester)
-> IO Requester -> IO (Maybe Requester)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Requester -> Requester)
-> Ptr Requester -> IO Requester
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Requester -> Requester
Requester Ptr Requester
ptr
        else Maybe Requester -> IO (Maybe Requester)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Requester
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveRequesterMethod (t :: Symbol) (o :: *) :: * where
    ResolveRequesterMethod "addFeature" o = Soup.SessionFeature.SessionFeatureAddFeatureMethodInfo
    ResolveRequesterMethod "attach" o = Soup.SessionFeature.SessionFeatureAttachMethodInfo
    ResolveRequesterMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveRequesterMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveRequesterMethod "detach" o = Soup.SessionFeature.SessionFeatureDetachMethodInfo
    ResolveRequesterMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveRequesterMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveRequesterMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveRequesterMethod "hasFeature" o = Soup.SessionFeature.SessionFeatureHasFeatureMethodInfo
    ResolveRequesterMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveRequesterMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveRequesterMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveRequesterMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveRequesterMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveRequesterMethod "removeFeature" o = Soup.SessionFeature.SessionFeatureRemoveFeatureMethodInfo
    ResolveRequesterMethod "request" o = RequesterRequestMethodInfo
    ResolveRequesterMethod "requestUri" o = RequesterRequestUriMethodInfo
    ResolveRequesterMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveRequesterMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveRequesterMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveRequesterMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveRequesterMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveRequesterMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveRequesterMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveRequesterMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveRequesterMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveRequesterMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveRequesterMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveRequesterMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveRequesterMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveRequesterMethod t Requester, O.OverloadedMethod info Requester p) => OL.IsLabel t (Requester -> 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 ~ ResolveRequesterMethod t Requester, O.OverloadedMethod info Requester p, R.HasField t Requester p) => R.HasField t Requester p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveRequesterMethod t Requester, O.OverloadedMethodInfo info Requester) => OL.IsLabel t (O.MethodProxy info Requester) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

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

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList Requester = RequesterSignalList
type RequesterSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method Requester::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Requester" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_requester_new" soup_requester_new :: 
    IO (Ptr Requester)

-- | /No description available in the introspection data./
requesterNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Requester
requesterNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Requester
requesterNew  = IO Requester -> m Requester
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Requester -> m Requester) -> IO Requester -> m Requester
forall a b. (a -> b) -> a -> b
$ do
    Ptr Requester
result <- IO (Ptr Requester)
soup_requester_new
    Text -> Ptr Requester -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"requesterNew" Ptr Requester
result
    Requester
result' <- ((ManagedPtr Requester -> Requester)
-> Ptr Requester -> IO Requester
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Requester -> Requester
Requester) Ptr Requester
result
    Requester -> IO Requester
forall (m :: * -> *) a. Monad m => a -> m a
return Requester
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Requester::request
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "requester"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Requester" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri_string"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Request" })
-- throws : True
-- Skip return : False

foreign import ccall "soup_requester_request" soup_requester_request :: 
    Ptr Requester ->                        -- requester : TInterface (Name {namespace = "Soup", name = "Requester"})
    CString ->                              -- uri_string : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Soup.Request.Request)

-- | /No description available in the introspection data./
requesterRequest ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequester a) =>
    a
    -> T.Text
    -> m Soup.Request.Request
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
requesterRequest :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRequester a) =>
a -> Text -> m Request
requesterRequest a
requester Text
uriString = IO Request -> m Request
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Request -> m Request) -> IO Request -> m Request
forall a b. (a -> b) -> a -> b
$ do
    Ptr Requester
requester' <- a -> IO (Ptr Requester)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
requester
    CString
uriString' <- Text -> IO CString
textToCString Text
uriString
    IO Request -> IO () -> IO Request
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Request
result <- (Ptr (Ptr GError) -> IO (Ptr Request)) -> IO (Ptr Request)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Request)) -> IO (Ptr Request))
-> (Ptr (Ptr GError) -> IO (Ptr Request)) -> IO (Ptr Request)
forall a b. (a -> b) -> a -> b
$ Ptr Requester -> CString -> Ptr (Ptr GError) -> IO (Ptr Request)
soup_requester_request Ptr Requester
requester' CString
uriString'
        Text -> Ptr Request -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"requesterRequest" Ptr Request
result
        Request
result' <- ((ManagedPtr Request -> Request) -> Ptr Request -> IO Request
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Request -> Request
Soup.Request.Request) Ptr Request
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
requester
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uriString'
        Request -> IO Request
forall (m :: * -> *) a. Monad m => a -> m a
return Request
result'
     ) (do
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uriString'
     )

#if defined(ENABLE_OVERLOADING)
data RequesterRequestMethodInfo
instance (signature ~ (T.Text -> m Soup.Request.Request), MonadIO m, IsRequester a) => O.OverloadedMethod RequesterRequestMethodInfo a signature where
    overloadedMethod = requesterRequest

instance O.OverloadedMethodInfo RequesterRequestMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Soup.Objects.Requester.requesterRequest",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Objects-Requester.html#v:requesterRequest"
        }


#endif

-- method Requester::request_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "requester"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Requester" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation { rawDocText = Nothing , 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 = Nothing , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Soup" , name = "Request" })
-- throws : True
-- Skip return : False

foreign import ccall "soup_requester_request_uri" soup_requester_request_uri :: 
    Ptr Requester ->                        -- requester : TInterface (Name {namespace = "Soup", name = "Requester"})
    Ptr Soup.URI.URI ->                     -- uri : TInterface (Name {namespace = "Soup", name = "URI"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Soup.Request.Request)

-- | /No description available in the introspection data./
requesterRequestUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequester a) =>
    a
    -> Soup.URI.URI
    -> m Soup.Request.Request
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
requesterRequestUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsRequester a) =>
a -> URI -> m Request
requesterRequestUri a
requester URI
uri = IO Request -> m Request
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Request -> m Request) -> IO Request -> m Request
forall a b. (a -> b) -> a -> b
$ do
    Ptr Requester
requester' <- a -> IO (Ptr Requester)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
requester
    Ptr URI
uri' <- URI -> IO (Ptr URI)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr URI
uri
    IO Request -> IO () -> IO Request
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr Request
result <- (Ptr (Ptr GError) -> IO (Ptr Request)) -> IO (Ptr Request)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Request)) -> IO (Ptr Request))
-> (Ptr (Ptr GError) -> IO (Ptr Request)) -> IO (Ptr Request)
forall a b. (a -> b) -> a -> b
$ Ptr Requester -> Ptr URI -> Ptr (Ptr GError) -> IO (Ptr Request)
soup_requester_request_uri Ptr Requester
requester' Ptr URI
uri'
        Text -> Ptr Request -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"requesterRequestUri" Ptr Request
result
        Request
result' <- ((ManagedPtr Request -> Request) -> Ptr Request -> IO Request
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Request -> Request
Soup.Request.Request) Ptr Request
result
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
requester
        URI -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr URI
uri
        Request -> IO Request
forall (m :: * -> *) a. Monad m => a -> m a
return Request
result'
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data RequesterRequestUriMethodInfo
instance (signature ~ (Soup.URI.URI -> m Soup.Request.Request), MonadIO m, IsRequester a) => O.OverloadedMethod RequesterRequestUriMethodInfo a signature where
    overloadedMethod = requesterRequestUri

instance O.OverloadedMethodInfo RequesterRequestUriMethodInfo a where
    overloadedMethodInfo = O.MethodInfo {
        O.overloadedMethodName = "GI.Soup.Objects.Requester.requesterRequestUri",
        O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-soup-2.4.24/docs/GI-Soup-Objects-Requester.html#v:requesterRequestUri"
        }


#endif