{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

A request to retrieve a particular URI.
-}

module GI.Soup.Objects.Request
    ( 

-- * Exported types
    Request(..)                             ,
    IsRequest                               ,
    toRequest                               ,
    noRequest                               ,


 -- * Methods
-- ** getContentLength #method:getContentLength#
    RequestGetContentLengthMethodInfo       ,
    requestGetContentLength                 ,


-- ** getContentType #method:getContentType#
    RequestGetContentTypeMethodInfo         ,
    requestGetContentType                   ,


-- ** getSession #method:getSession#
    RequestGetSessionMethodInfo             ,
    requestGetSession                       ,


-- ** getUri #method:getUri#
    RequestGetUriMethodInfo                 ,
    requestGetUri                           ,


-- ** send #method:send#
    RequestSendMethodInfo                   ,
    requestSend                             ,


-- ** sendAsync #method:sendAsync#
    RequestSendAsyncMethodInfo              ,
    requestSendAsync                        ,


-- ** sendFinish #method:sendFinish#
    RequestSendFinishMethodInfo             ,
    requestSendFinish                       ,




 -- * Properties
-- ** session #attr:session#
    RequestSessionPropertyInfo              ,
    constructRequestSession                 ,
    getRequestSession                       ,
    requestSession                          ,


-- ** uri #attr:uri#
    RequestUriPropertyInfo                  ,
    constructRequestUri                     ,
    getRequestUri                           ,
    requestUri                              ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import qualified GI.Gio.Interfaces.Initable as Gio.Initable
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import {-# SOURCE #-} qualified GI.Soup.Objects.Session as Soup.Session
import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI

newtype Request = Request (ManagedPtr Request)
foreign import ccall "soup_request_get_type"
    c_soup_request_get_type :: IO GType

instance GObject Request where
    gobjectType _ = c_soup_request_get_type
    

class GObject o => IsRequest o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError Request a) =>
    IsRequest a
#endif
instance IsRequest Request
instance GObject.Object.IsObject Request
instance Gio.Initable.IsInitable Request

toRequest :: IsRequest o => o -> IO Request
toRequest = unsafeCastTo Request

noRequest :: Maybe Request
noRequest = Nothing

type family ResolveRequestMethod (t :: Symbol) (o :: *) :: * where
    ResolveRequestMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveRequestMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveRequestMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveRequestMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveRequestMethod "init" o = Gio.Initable.InitableInitMethodInfo
    ResolveRequestMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveRequestMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveRequestMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveRequestMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveRequestMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveRequestMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveRequestMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveRequestMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveRequestMethod "send" o = RequestSendMethodInfo
    ResolveRequestMethod "sendAsync" o = RequestSendAsyncMethodInfo
    ResolveRequestMethod "sendFinish" o = RequestSendFinishMethodInfo
    ResolveRequestMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveRequestMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveRequestMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveRequestMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveRequestMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveRequestMethod "getContentLength" o = RequestGetContentLengthMethodInfo
    ResolveRequestMethod "getContentType" o = RequestGetContentTypeMethodInfo
    ResolveRequestMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveRequestMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveRequestMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveRequestMethod "getSession" o = RequestGetSessionMethodInfo
    ResolveRequestMethod "getUri" o = RequestGetUriMethodInfo
    ResolveRequestMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveRequestMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveRequestMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveRequestMethod t Request, O.MethodInfo info Request p) => O.IsLabelProxy t (Request -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveRequestMethod t Request, O.MethodInfo info Request p) => O.IsLabel t (Request -> p) where
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif

-- VVV Prop "session"
   -- Type: TInterface (Name {namespace = "Soup", name = "Session"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getRequestSession :: (MonadIO m, IsRequest o) => o -> m Soup.Session.Session
getRequestSession obj = liftIO $ checkUnexpectedNothing "getRequestSession" $ getObjectPropertyObject obj "session" Soup.Session.Session

constructRequestSession :: (IsRequest o, Soup.Session.IsSession a) => a -> IO (GValueConstruct o)
constructRequestSession val = constructObjectPropertyObject "session" (Just val)

data RequestSessionPropertyInfo
instance AttrInfo RequestSessionPropertyInfo where
    type AttrAllowedOps RequestSessionPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint RequestSessionPropertyInfo = Soup.Session.IsSession
    type AttrBaseTypeConstraint RequestSessionPropertyInfo = IsRequest
    type AttrGetType RequestSessionPropertyInfo = Soup.Session.Session
    type AttrLabel RequestSessionPropertyInfo = "session"
    type AttrOrigin RequestSessionPropertyInfo = Request
    attrGet _ = getRequestSession
    attrSet _ = undefined
    attrConstruct _ = constructRequestSession
    attrClear _ = undefined

-- VVV Prop "uri"
   -- Type: TInterface (Name {namespace = "Soup", name = "URI"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getRequestUri :: (MonadIO m, IsRequest o) => o -> m Soup.URI.URI
getRequestUri obj = liftIO $ checkUnexpectedNothing "getRequestUri" $ getObjectPropertyBoxed obj "uri" Soup.URI.URI

constructRequestUri :: (IsRequest o) => Soup.URI.URI -> IO (GValueConstruct o)
constructRequestUri val = constructObjectPropertyBoxed "uri" (Just val)

data RequestUriPropertyInfo
instance AttrInfo RequestUriPropertyInfo where
    type AttrAllowedOps RequestUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint RequestUriPropertyInfo = (~) Soup.URI.URI
    type AttrBaseTypeConstraint RequestUriPropertyInfo = IsRequest
    type AttrGetType RequestUriPropertyInfo = Soup.URI.URI
    type AttrLabel RequestUriPropertyInfo = "uri"
    type AttrOrigin RequestUriPropertyInfo = Request
    attrGet _ = getRequestUri
    attrSet _ = undefined
    attrConstruct _ = constructRequestUri
    attrClear _ = undefined

instance O.HasAttributeList Request
type instance O.AttributeList Request = RequestAttributeList
type RequestAttributeList = ('[ '("session", RequestSessionPropertyInfo), '("uri", RequestUriPropertyInfo)] :: [(Symbol, *)])

requestSession :: AttrLabelProxy "session"
requestSession = AttrLabelProxy

requestUri :: AttrLabelProxy "uri"
requestUri = AttrLabelProxy

type instance O.SignalList Request = RequestSignalList
type RequestSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

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

foreign import ccall "soup_request_get_content_length" soup_request_get_content_length :: 
    Ptr Request ->                          -- request : TInterface (Name {namespace = "Soup", name = "Request"})
    IO Int64

{- |
Gets the length of the data represented by /@request@/. For most
request types, this will not be known until after you call
'GI.Soup.Objects.Request.requestSend' or 'GI.Soup.Objects.Request.requestSendFinish'.

@since 2.42
-}
requestGetContentLength ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequest a) =>
    a
    {- ^ /@request@/: a 'GI.Soup.Objects.Request.Request' -}
    -> m Int64
    {- ^ __Returns:__ the length of the data represented by /@request@/,
  or -1 if not known. -}
requestGetContentLength request = liftIO $ do
    request' <- unsafeManagedPtrCastPtr request
    result <- soup_request_get_content_length request'
    touchManagedPtr request
    return result

data RequestGetContentLengthMethodInfo
instance (signature ~ (m Int64), MonadIO m, IsRequest a) => O.MethodInfo RequestGetContentLengthMethodInfo a signature where
    overloadedMethod _ = requestGetContentLength

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

foreign import ccall "soup_request_get_content_type" soup_request_get_content_type :: 
    Ptr Request ->                          -- request : TInterface (Name {namespace = "Soup", name = "Request"})
    IO CString

{- |
Gets the type of the data represented by /@request@/. For most request
types, this will not be known until after you call
'GI.Soup.Objects.Request.requestSend' or 'GI.Soup.Objects.Request.requestSendFinish'.

As in the HTTP Content-Type header, this may include parameters
after the MIME type.

@since 2.42
-}
requestGetContentType ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequest a) =>
    a
    {- ^ /@request@/: a 'GI.Soup.Objects.Request.Request' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ the type of the data represented by
  /@request@/, or 'Nothing' if not known. -}
requestGetContentType request = liftIO $ do
    request' <- unsafeManagedPtrCastPtr request
    result <- soup_request_get_content_type request'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr request
    return maybeResult

data RequestGetContentTypeMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsRequest a) => O.MethodInfo RequestGetContentTypeMethodInfo a signature where
    overloadedMethod _ = requestGetContentType

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

foreign import ccall "soup_request_get_session" soup_request_get_session :: 
    Ptr Request ->                          -- request : TInterface (Name {namespace = "Soup", name = "Request"})
    IO (Ptr Soup.Session.Session)

{- |
Gets /@request@/\'s 'GI.Soup.Objects.Session.Session'

@since 2.42
-}
requestGetSession ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequest a) =>
    a
    {- ^ /@request@/: a 'GI.Soup.Objects.Request.Request' -}
    -> m Soup.Session.Session
    {- ^ __Returns:__ /@request@/\'s 'GI.Soup.Objects.Session.Session' -}
requestGetSession request = liftIO $ do
    request' <- unsafeManagedPtrCastPtr request
    result <- soup_request_get_session request'
    checkUnexpectedReturnNULL "requestGetSession" result
    result' <- (newObject Soup.Session.Session) result
    touchManagedPtr request
    return result'

data RequestGetSessionMethodInfo
instance (signature ~ (m Soup.Session.Session), MonadIO m, IsRequest a) => O.MethodInfo RequestGetSessionMethodInfo a signature where
    overloadedMethod _ = requestGetSession

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

foreign import ccall "soup_request_get_uri" soup_request_get_uri :: 
    Ptr Request ->                          -- request : TInterface (Name {namespace = "Soup", name = "Request"})
    IO (Ptr Soup.URI.URI)

{- |
Gets /@request@/\'s URI

@since 2.42
-}
requestGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequest a) =>
    a
    {- ^ /@request@/: a 'GI.Soup.Objects.Request.Request' -}
    -> m Soup.URI.URI
    {- ^ __Returns:__ /@request@/\'s URI -}
requestGetUri request = liftIO $ do
    request' <- unsafeManagedPtrCastPtr request
    result <- soup_request_get_uri request'
    checkUnexpectedReturnNULL "requestGetUri" result
    result' <- (newBoxed Soup.URI.URI) result
    touchManagedPtr request
    return result'

data RequestGetUriMethodInfo
instance (signature ~ (m Soup.URI.URI), MonadIO m, IsRequest a) => O.MethodInfo RequestGetUriMethodInfo a signature where
    overloadedMethod _ = requestGetUri

-- method Request::send
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "Soup", name = "Request"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupRequest", 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}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "InputStream"}))
-- throws : True
-- Skip return : False

foreign import ccall "soup_request_send" soup_request_send :: 
    Ptr Request ->                          -- request : TInterface (Name {namespace = "Soup", name = "Request"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.InputStream.InputStream)

{- |
Synchronously requests the URI pointed to by /@request@/, and returns
a 'GI.Gio.Objects.InputStream.InputStream' that can be used to read its contents.

Note that you cannot use this method with @/SoupRequests/@ attached to
a 'GI.Soup.Objects.SessionAsync.SessionAsync'.

@since 2.42
-}
requestSend ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequest a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@request@/: a 'GI.Soup.Objects.Request.Request' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> m Gio.InputStream.InputStream
    {- ^ __Returns:__ a 'GI.Gio.Objects.InputStream.InputStream' that can be used to
  read from the URI pointed to by /@request@/. /(Can throw 'Data.GI.Base.GError.GError')/ -}
requestSend request cancellable = liftIO $ do
    request' <- unsafeManagedPtrCastPtr request
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    onException (do
        result <- propagateGError $ soup_request_send request' maybeCancellable
        checkUnexpectedReturnNULL "requestSend" result
        result' <- (wrapObject Gio.InputStream.InputStream) result
        touchManagedPtr request
        whenJust cancellable touchManagedPtr
        return result'
     ) (do
        return ()
     )

data RequestSendMethodInfo
instance (signature ~ (Maybe (b) -> m Gio.InputStream.InputStream), MonadIO m, IsRequest a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RequestSendMethodInfo a signature where
    overloadedMethod _ = requestSend

-- method Request::send_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "Soup", name = "Request"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupRequest", 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 = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 3, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data passed to @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_request_send_async" soup_request_send_async :: 
    Ptr Request ->                          -- request : TInterface (Name {namespace = "Soup", name = "Request"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

{- |
Begins an asynchronously request for the URI pointed to by
/@request@/.

Note that you cannot use this method with @/SoupRequests/@ attached to
a 'GI.Soup.Objects.SessionSync.SessionSync'.

@since 2.42
-}
requestSendAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequest a, Gio.Cancellable.IsCancellable b) =>
    a
    {- ^ /@request@/: a 'GI.Soup.Objects.Request.Request' -}
    -> Maybe (b)
    {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable' or 'Nothing' -}
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' -}
    -> m ()
requestSendAsync request cancellable callback = liftIO $ do
    request' <- unsafeManagedPtrCastPtr request
    maybeCancellable <- case cancellable of
        Nothing -> return nullPtr
        Just jCancellable -> do
            jCancellable' <- unsafeManagedPtrCastPtr jCancellable
            return jCancellable'
    ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
    maybeCallback <- case callback of
        Nothing -> return (castPtrToFunPtr nullPtr)
        Just jCallback -> do
            jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
            poke ptrcallback jCallback'
            return jCallback'
    let userData = nullPtr
    soup_request_send_async request' maybeCancellable maybeCallback userData
    touchManagedPtr request
    whenJust cancellable touchManagedPtr
    return ()

data RequestSendAsyncMethodInfo
instance (signature ~ (Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsRequest a, Gio.Cancellable.IsCancellable b) => O.MethodInfo RequestSendAsyncMethodInfo a signature where
    overloadedMethod _ = requestSendAsync

-- method Request::send_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "request", argType = TInterface (Name {namespace = "Soup", name = "Request"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupRequest", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "InputStream"}))
-- throws : True
-- Skip return : False

foreign import ccall "soup_request_send_finish" soup_request_send_finish :: 
    Ptr Request ->                          -- request : TInterface (Name {namespace = "Soup", name = "Request"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.InputStream.InputStream)

{- |
Gets the result of a 'GI.Soup.Objects.Request.requestSendAsync'.

@since 2.42
-}
requestSendFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsRequest a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    {- ^ /@request@/: a 'GI.Soup.Objects.Request.Request' -}
    -> b
    {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
    -> m Gio.InputStream.InputStream
    {- ^ __Returns:__ a 'GI.Gio.Objects.InputStream.InputStream' that can be used to
  read from the URI pointed to by /@request@/. /(Can throw 'Data.GI.Base.GError.GError')/ -}
requestSendFinish request result_ = liftIO $ do
    request' <- unsafeManagedPtrCastPtr request
    result_' <- unsafeManagedPtrCastPtr result_
    onException (do
        result <- propagateGError $ soup_request_send_finish request' result_'
        checkUnexpectedReturnNULL "requestSendFinish" result
        result' <- (wrapObject Gio.InputStream.InputStream) result
        touchManagedPtr request
        touchManagedPtr result_
        return result'
     ) (do
        return ()
     )

data RequestSendFinishMethodInfo
instance (signature ~ (b -> m Gio.InputStream.InputStream), MonadIO m, IsRequest a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo RequestSendFinishMethodInfo a signature where
    overloadedMethod _ = requestSendFinish