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

-- * Exported types
    MultipartInputStream(..)                ,
    IsMultipartInputStream                  ,
    toMultipartInputStream                  ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveMultipartInputStreamMethod       ,
#endif


-- ** getHeaders #method:getHeaders#

#if defined(ENABLE_OVERLOADING)
    MultipartInputStreamGetHeadersMethodInfo,
#endif
    multipartInputStreamGetHeaders          ,


-- ** new #method:new#

    multipartInputStreamNew                 ,


-- ** nextPart #method:nextPart#

#if defined(ENABLE_OVERLOADING)
    MultipartInputStreamNextPartMethodInfo  ,
#endif
    multipartInputStreamNextPart            ,


-- ** nextPartAsync #method:nextPartAsync#

#if defined(ENABLE_OVERLOADING)
    MultipartInputStreamNextPartAsyncMethodInfo,
#endif
    multipartInputStreamNextPartAsync       ,


-- ** nextPartFinish #method:nextPartFinish#

#if defined(ENABLE_OVERLOADING)
    MultipartInputStreamNextPartFinishMethodInfo,
#endif
    multipartInputStreamNextPartFinish      ,




 -- * Properties
-- ** message #attr:message#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    MultipartInputStreamMessagePropertyInfo ,
#endif
    constructMultipartInputStreamMessage    ,
    getMultipartInputStreamMessage          ,
#if defined(ENABLE_OVERLOADING)
    multipartInputStreamMessage             ,
#endif




    ) 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.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.PollableInputStream as Gio.PollableInputStream
import qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import qualified GI.Gio.Objects.FilterInputStream as Gio.FilterInputStream
import qualified GI.Gio.Objects.InputStream as Gio.InputStream
import {-# SOURCE #-} qualified GI.Soup.Objects.Message as Soup.Message
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders

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

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

foreign import ccall "soup_multipart_input_stream_get_type"
    c_soup_multipart_input_stream_get_type :: IO B.Types.GType

instance B.Types.TypedObject MultipartInputStream where
    glibType :: IO GType
glibType = IO GType
c_soup_multipart_input_stream_get_type

instance B.Types.GObject MultipartInputStream

-- | Convert 'MultipartInputStream' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue MultipartInputStream where
    toGValue :: MultipartInputStream -> IO GValue
toGValue MultipartInputStream
o = do
        GType
gtype <- IO GType
c_soup_multipart_input_stream_get_type
        MultipartInputStream
-> (Ptr MultipartInputStream -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MultipartInputStream
o (GType
-> (GValue -> Ptr MultipartInputStream -> IO ())
-> Ptr MultipartInputStream
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr MultipartInputStream -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO MultipartInputStream
fromGValue GValue
gv = do
        Ptr MultipartInputStream
ptr <- GValue -> IO (Ptr MultipartInputStream)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr MultipartInputStream)
        (ManagedPtr MultipartInputStream -> MultipartInputStream)
-> Ptr MultipartInputStream -> IO MultipartInputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr MultipartInputStream -> MultipartInputStream
MultipartInputStream Ptr MultipartInputStream
ptr
        
    

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

instance O.HasParentTypes MultipartInputStream
type instance O.ParentTypes MultipartInputStream = '[Gio.FilterInputStream.FilterInputStream, Gio.InputStream.InputStream, GObject.Object.Object, Gio.PollableInputStream.PollableInputStream]

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

#if defined(ENABLE_OVERLOADING)
type family ResolveMultipartInputStreamMethod (t :: Symbol) (o :: *) :: * where
    ResolveMultipartInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveMultipartInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveMultipartInputStreamMethod "canPoll" o = Gio.PollableInputStream.PollableInputStreamCanPollMethodInfo
    ResolveMultipartInputStreamMethod "clearPending" o = Gio.InputStream.InputStreamClearPendingMethodInfo
    ResolveMultipartInputStreamMethod "close" o = Gio.InputStream.InputStreamCloseMethodInfo
    ResolveMultipartInputStreamMethod "closeAsync" o = Gio.InputStream.InputStreamCloseAsyncMethodInfo
    ResolveMultipartInputStreamMethod "closeFinish" o = Gio.InputStream.InputStreamCloseFinishMethodInfo
    ResolveMultipartInputStreamMethod "createSource" o = Gio.PollableInputStream.PollableInputStreamCreateSourceMethodInfo
    ResolveMultipartInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveMultipartInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveMultipartInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveMultipartInputStreamMethod "hasPending" o = Gio.InputStream.InputStreamHasPendingMethodInfo
    ResolveMultipartInputStreamMethod "isClosed" o = Gio.InputStream.InputStreamIsClosedMethodInfo
    ResolveMultipartInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveMultipartInputStreamMethod "isReadable" o = Gio.PollableInputStream.PollableInputStreamIsReadableMethodInfo
    ResolveMultipartInputStreamMethod "nextPart" o = MultipartInputStreamNextPartMethodInfo
    ResolveMultipartInputStreamMethod "nextPartAsync" o = MultipartInputStreamNextPartAsyncMethodInfo
    ResolveMultipartInputStreamMethod "nextPartFinish" o = MultipartInputStreamNextPartFinishMethodInfo
    ResolveMultipartInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveMultipartInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveMultipartInputStreamMethod "read" o = Gio.InputStream.InputStreamReadMethodInfo
    ResolveMultipartInputStreamMethod "readAll" o = Gio.InputStream.InputStreamReadAllMethodInfo
    ResolveMultipartInputStreamMethod "readAllAsync" o = Gio.InputStream.InputStreamReadAllAsyncMethodInfo
    ResolveMultipartInputStreamMethod "readAllFinish" o = Gio.InputStream.InputStreamReadAllFinishMethodInfo
    ResolveMultipartInputStreamMethod "readAsync" o = Gio.InputStream.InputStreamReadAsyncMethodInfo
    ResolveMultipartInputStreamMethod "readBytes" o = Gio.InputStream.InputStreamReadBytesMethodInfo
    ResolveMultipartInputStreamMethod "readBytesAsync" o = Gio.InputStream.InputStreamReadBytesAsyncMethodInfo
    ResolveMultipartInputStreamMethod "readBytesFinish" o = Gio.InputStream.InputStreamReadBytesFinishMethodInfo
    ResolveMultipartInputStreamMethod "readFinish" o = Gio.InputStream.InputStreamReadFinishMethodInfo
    ResolveMultipartInputStreamMethod "readNonblocking" o = Gio.PollableInputStream.PollableInputStreamReadNonblockingMethodInfo
    ResolveMultipartInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveMultipartInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveMultipartInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveMultipartInputStreamMethod "skip" o = Gio.InputStream.InputStreamSkipMethodInfo
    ResolveMultipartInputStreamMethod "skipAsync" o = Gio.InputStream.InputStreamSkipAsyncMethodInfo
    ResolveMultipartInputStreamMethod "skipFinish" o = Gio.InputStream.InputStreamSkipFinishMethodInfo
    ResolveMultipartInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveMultipartInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveMultipartInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveMultipartInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveMultipartInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveMultipartInputStreamMethod "getBaseStream" o = Gio.FilterInputStream.FilterInputStreamGetBaseStreamMethodInfo
    ResolveMultipartInputStreamMethod "getCloseBaseStream" o = Gio.FilterInputStream.FilterInputStreamGetCloseBaseStreamMethodInfo
    ResolveMultipartInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveMultipartInputStreamMethod "getHeaders" o = MultipartInputStreamGetHeadersMethodInfo
    ResolveMultipartInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveMultipartInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveMultipartInputStreamMethod "setCloseBaseStream" o = Gio.FilterInputStream.FilterInputStreamSetCloseBaseStreamMethodInfo
    ResolveMultipartInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveMultipartInputStreamMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveMultipartInputStreamMethod "setPending" o = Gio.InputStream.InputStreamSetPendingMethodInfo
    ResolveMultipartInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveMultipartInputStreamMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveMultipartInputStreamMethod t MultipartInputStream, O.MethodInfo info MultipartInputStream p) => OL.IsLabel t (MultipartInputStream -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

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

-- | Get the value of the “@message@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' multipartInputStream #message
-- @
getMultipartInputStreamMessage :: (MonadIO m, IsMultipartInputStream o) => o -> m (Maybe Soup.Message.Message)
getMultipartInputStreamMessage :: o -> m (Maybe Message)
getMultipartInputStreamMessage o
obj = IO (Maybe Message) -> m (Maybe Message)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Message) -> m (Maybe Message))
-> IO (Maybe Message) -> m (Maybe Message)
forall a b. (a -> b) -> a -> b
$ o
-> String -> (ManagedPtr Message -> Message) -> IO (Maybe Message)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"message" ManagedPtr Message -> Message
Soup.Message.Message

-- | Construct a `GValueConstruct` with valid value for the “@message@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructMultipartInputStreamMessage :: (IsMultipartInputStream o, MIO.MonadIO m, Soup.Message.IsMessage a) => a -> m (GValueConstruct o)
constructMultipartInputStreamMessage :: a -> m (GValueConstruct o)
constructMultipartInputStreamMessage a
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject String
"message" (a -> Maybe a
forall a. a -> Maybe a
P.Just a
val)

#if defined(ENABLE_OVERLOADING)
data MultipartInputStreamMessagePropertyInfo
instance AttrInfo MultipartInputStreamMessagePropertyInfo where
    type AttrAllowedOps MultipartInputStreamMessagePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint MultipartInputStreamMessagePropertyInfo = IsMultipartInputStream
    type AttrSetTypeConstraint MultipartInputStreamMessagePropertyInfo = Soup.Message.IsMessage
    type AttrTransferTypeConstraint MultipartInputStreamMessagePropertyInfo = Soup.Message.IsMessage
    type AttrTransferType MultipartInputStreamMessagePropertyInfo = Soup.Message.Message
    type AttrGetType MultipartInputStreamMessagePropertyInfo = (Maybe Soup.Message.Message)
    type AttrLabel MultipartInputStreamMessagePropertyInfo = "message"
    type AttrOrigin MultipartInputStreamMessagePropertyInfo = MultipartInputStream
    attrGet = getMultipartInputStreamMessage
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Soup.Message.Message v
    attrConstruct = constructMultipartInputStreamMessage
    attrClear = undefined
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MultipartInputStream
type instance O.AttributeList MultipartInputStream = MultipartInputStreamAttributeList
type MultipartInputStreamAttributeList = ('[ '("baseStream", Gio.FilterInputStream.FilterInputStreamBaseStreamPropertyInfo), '("closeBaseStream", Gio.FilterInputStream.FilterInputStreamCloseBaseStreamPropertyInfo), '("message", MultipartInputStreamMessagePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
multipartInputStreamMessage :: AttrLabelProxy "message"
multipartInputStreamMessage = AttrLabelProxy

#endif

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

#endif

-- method MultipartInputStream::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupMessage the response is related to."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "base_stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "InputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the #GInputStream returned by sending the request."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Soup" , name = "MultipartInputStream" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_multipart_input_stream_new" soup_multipart_input_stream_new :: 
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    Ptr Gio.InputStream.InputStream ->      -- base_stream : TInterface (Name {namespace = "Gio", name = "InputStream"})
    IO (Ptr MultipartInputStream)

-- | Creates a new t'GI.Soup.Objects.MultipartInputStream.MultipartInputStream' that wraps the
-- t'GI.Gio.Objects.InputStream.InputStream' obtained by sending the t'GI.Soup.Objects.Request.Request'. Reads should
-- not be done directly through this object, use the input streams
-- returned by 'GI.Soup.Objects.MultipartInputStream.multipartInputStreamNextPart' or its async
-- counterpart instead.
-- 
-- /Since: 2.40/
multipartInputStreamNew ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a, Gio.InputStream.IsInputStream b) =>
    a
    -- ^ /@msg@/: the t'GI.Soup.Objects.Message.Message' the response is related to.
    -> b
    -- ^ /@baseStream@/: the t'GI.Gio.Objects.InputStream.InputStream' returned by sending the request.
    -> m MultipartInputStream
    -- ^ __Returns:__ a new t'GI.Soup.Objects.MultipartInputStream.MultipartInputStream'
multipartInputStreamNew :: a -> b -> m MultipartInputStream
multipartInputStreamNew a
msg b
baseStream = IO MultipartInputStream -> m MultipartInputStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MultipartInputStream -> m MultipartInputStream)
-> IO MultipartInputStream -> m MultipartInputStream
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr InputStream
baseStream' <- b -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
baseStream
    Ptr MultipartInputStream
result <- Ptr Message -> Ptr InputStream -> IO (Ptr MultipartInputStream)
soup_multipart_input_stream_new Ptr Message
msg' Ptr InputStream
baseStream'
    Text -> Ptr MultipartInputStream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"multipartInputStreamNew" Ptr MultipartInputStream
result
    MultipartInputStream
result' <- ((ManagedPtr MultipartInputStream -> MultipartInputStream)
-> Ptr MultipartInputStream -> IO MultipartInputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr MultipartInputStream -> MultipartInputStream
MultipartInputStream) Ptr MultipartInputStream
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
baseStream
    MultipartInputStream -> IO MultipartInputStream
forall (m :: * -> *) a. Monad m => a -> m a
return MultipartInputStream
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "soup_multipart_input_stream_get_headers" soup_multipart_input_stream_get_headers :: 
    Ptr MultipartInputStream ->             -- multipart : TInterface (Name {namespace = "Soup", name = "MultipartInputStream"})
    IO (Ptr Soup.MessageHeaders.MessageHeaders)

-- | Obtains the headers for the part currently being processed. Note
-- that the t'GI.Soup.Structs.MessageHeaders.MessageHeaders' that are returned are owned by the
-- t'GI.Soup.Objects.MultipartInputStream.MultipartInputStream' and will be replaced when a call is made
-- to 'GI.Soup.Objects.MultipartInputStream.multipartInputStreamNextPart' or its async
-- counterpart, so if keeping the headers is required, a copy must be
-- made.
-- 
-- Note that if a part had no headers at all an empty t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
-- will be returned.
-- 
-- /Since: 2.40/
multipartInputStreamGetHeaders ::
    (B.CallStack.HasCallStack, MonadIO m, IsMultipartInputStream a) =>
    a
    -- ^ /@multipart@/: a t'GI.Soup.Objects.MultipartInputStream.MultipartInputStream'.
    -> m (Maybe Soup.MessageHeaders.MessageHeaders)
    -- ^ __Returns:__ a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -- containing the headers for the part currently being processed or
    -- 'P.Nothing' if the headers failed to parse.
multipartInputStreamGetHeaders :: a -> m (Maybe MessageHeaders)
multipartInputStreamGetHeaders a
multipart = IO (Maybe MessageHeaders) -> m (Maybe MessageHeaders)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MessageHeaders) -> m (Maybe MessageHeaders))
-> IO (Maybe MessageHeaders) -> m (Maybe MessageHeaders)
forall a b. (a -> b) -> a -> b
$ do
    Ptr MultipartInputStream
multipart' <- a -> IO (Ptr MultipartInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
multipart
    Ptr MessageHeaders
result <- Ptr MultipartInputStream -> IO (Ptr MessageHeaders)
soup_multipart_input_stream_get_headers Ptr MultipartInputStream
multipart'
    Maybe MessageHeaders
maybeResult <- Ptr MessageHeaders
-> (Ptr MessageHeaders -> IO MessageHeaders)
-> IO (Maybe MessageHeaders)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr MessageHeaders
result ((Ptr MessageHeaders -> IO MessageHeaders)
 -> IO (Maybe MessageHeaders))
-> (Ptr MessageHeaders -> IO MessageHeaders)
-> IO (Maybe MessageHeaders)
forall a b. (a -> b) -> a -> b
$ \Ptr MessageHeaders
result' -> do
        MessageHeaders
result'' <- ((ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageHeaders -> MessageHeaders
Soup.MessageHeaders.MessageHeaders) Ptr MessageHeaders
result'
        MessageHeaders -> IO MessageHeaders
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeaders
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
multipart
    Maybe MessageHeaders -> IO (Maybe MessageHeaders)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MessageHeaders
maybeResult

#if defined(ENABLE_OVERLOADING)
data MultipartInputStreamGetHeadersMethodInfo
instance (signature ~ (m (Maybe Soup.MessageHeaders.MessageHeaders)), MonadIO m, IsMultipartInputStream a) => O.MethodInfo MultipartInputStreamGetHeadersMethodInfo a signature where
    overloadedMethod = multipartInputStreamGetHeaders

#endif

-- method MultipartInputStream::next_part
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "multipart"
--           , argType =
--               TInterface
--                 Name { namespace = "Soup" , name = "MultipartInputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupMultipartInputStream"
--                 , 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" , 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_multipart_input_stream_next_part" soup_multipart_input_stream_next_part :: 
    Ptr MultipartInputStream ->             -- multipart : TInterface (Name {namespace = "Soup", name = "MultipartInputStream"})
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.InputStream.InputStream)

-- | Obtains an input stream for the next part. When dealing with a
-- multipart response the input stream needs to be wrapped in a
-- t'GI.Soup.Objects.MultipartInputStream.MultipartInputStream' and this function or its async
-- counterpart need to be called to obtain the first part for
-- reading.
-- 
-- After calling this function,
-- 'GI.Soup.Objects.MultipartInputStream.multipartInputStreamGetHeaders' can be used to obtain the
-- headers for the first part. A read of 0 bytes indicates the end of
-- the part; a new call to this function should be done at that point,
-- to obtain the next part.
-- 
-- /Since: 2.40/
multipartInputStreamNextPart ::
    (B.CallStack.HasCallStack, MonadIO m, IsMultipartInputStream a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@multipart@/: the t'GI.Soup.Objects.MultipartInputStream.MultipartInputStream'
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'
    -> m (Maybe Gio.InputStream.InputStream)
    -- ^ __Returns:__ a new t'GI.Gio.Objects.InputStream.InputStream', or
    -- 'P.Nothing' if there are no more parts /(Can throw 'Data.GI.Base.GError.GError')/
multipartInputStreamNextPart :: a -> Maybe b -> m (Maybe InputStream)
multipartInputStreamNextPart a
multipart Maybe b
cancellable = IO (Maybe InputStream) -> m (Maybe InputStream)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStream) -> m (Maybe InputStream))
-> IO (Maybe InputStream) -> m (Maybe InputStream)
forall a b. (a -> b) -> a -> b
$ do
    Ptr MultipartInputStream
multipart' <- a -> IO (Ptr MultipartInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
multipart
    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'
    IO (Maybe InputStream) -> IO () -> IO (Maybe InputStream)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr InputStream
result <- (Ptr (Ptr GError) -> IO (Ptr InputStream)) -> IO (Ptr InputStream)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr InputStream))
 -> IO (Ptr InputStream))
-> (Ptr (Ptr GError) -> IO (Ptr InputStream))
-> IO (Ptr InputStream)
forall a b. (a -> b) -> a -> b
$ Ptr MultipartInputStream
-> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr InputStream)
soup_multipart_input_stream_next_part Ptr MultipartInputStream
multipart' Ptr Cancellable
maybeCancellable
        Maybe InputStream
maybeResult <- Ptr InputStream
-> (Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr InputStream
result ((Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream))
-> (Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStream
result' -> do
            InputStream
result'' <- ((ManagedPtr InputStream -> InputStream)
-> Ptr InputStream -> IO InputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
result'
            InputStream -> IO InputStream
forall (m :: * -> *) a. Monad m => a -> m a
return InputStream
result''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
multipart
        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
        Maybe InputStream -> IO (Maybe InputStream)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStream
maybeResult
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data MultipartInputStreamNextPartMethodInfo
instance (signature ~ (Maybe (b) -> m (Maybe Gio.InputStream.InputStream)), MonadIO m, IsMultipartInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo MultipartInputStreamNextPartMethodInfo a signature where
    overloadedMethod = multipartInputStreamNextPart

#endif

-- method MultipartInputStream::next_part_async
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "multipart"
--           , argType =
--               TInterface
--                 Name { namespace = "Soup" , name = "MultipartInputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #SoupMultipartInputStream."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "io_priority"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the I/O priority for the request."
--                 , 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." , 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 "callback to call when request is satisfied."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeAsync
--           , argClosure = 4
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "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_multipart_input_stream_next_part_async" soup_multipart_input_stream_next_part_async :: 
    Ptr MultipartInputStream ->             -- multipart : TInterface (Name {namespace = "Soup", name = "MultipartInputStream"})
    Int32 ->                                -- io_priority : TBasicType TInt
    Ptr Gio.Cancellable.Cancellable ->      -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
    FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
    Ptr () ->                               -- data : TBasicType TPtr
    IO ()

-- | Obtains a t'GI.Gio.Objects.InputStream.InputStream' for the next request. See
-- 'GI.Soup.Objects.MultipartInputStream.multipartInputStreamNextPart' for details on the
-- workflow.
-- 
-- /Since: 2.40/
multipartInputStreamNextPartAsync ::
    (B.CallStack.HasCallStack, MonadIO m, IsMultipartInputStream a, Gio.Cancellable.IsCancellable b) =>
    a
    -- ^ /@multipart@/: the t'GI.Soup.Objects.MultipartInputStream.MultipartInputStream'.
    -> Int32
    -- ^ /@ioPriority@/: the I\/O priority for the request.
    -> Maybe (b)
    -- ^ /@cancellable@/: a t'GI.Gio.Objects.Cancellable.Cancellable'.
    -> Maybe (Gio.Callbacks.AsyncReadyCallback)
    -- ^ /@callback@/: callback to call when request is satisfied.
    -> m ()
multipartInputStreamNextPartAsync :: a -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
multipartInputStreamNextPartAsync a
multipart Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
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 MultipartInputStream
multipart' <- a -> IO (Ptr MultipartInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
multipart
    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'
    FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
        Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return (Ptr Any -> FunPtr C_AsyncReadyCallback
forall a b. Ptr a -> FunPtr b
castPtrToFunPtr Ptr Any
forall a. Ptr a
nullPtr)
        Just AsyncReadyCallback
jCallback -> do
            Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
            FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback_WithClosures -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (Ptr (FunPtr C_AsyncReadyCallback)
-> Maybe (Ptr (FunPtr C_AsyncReadyCallback))
forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) (AsyncReadyCallback -> AsyncReadyCallback_WithClosures
Gio.Callbacks.drop_closures_AsyncReadyCallback AsyncReadyCallback
jCallback))
            Ptr (FunPtr C_AsyncReadyCallback)
-> FunPtr C_AsyncReadyCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
            FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
    let data_ :: Ptr a
data_ = Ptr a
forall a. Ptr a
nullPtr
    Ptr MultipartInputStream
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
soup_multipart_input_stream_next_part_async Ptr MultipartInputStream
multipart' Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback Ptr ()
forall a. Ptr a
data_
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
multipart
    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 MultipartInputStreamNextPartAsyncMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsMultipartInputStream a, Gio.Cancellable.IsCancellable b) => O.MethodInfo MultipartInputStreamNextPartAsyncMethodInfo a signature where
    overloadedMethod = multipartInputStreamNextPartAsync

#endif

-- method MultipartInputStream::next_part_finish
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "multipart"
--           , argType =
--               TInterface
--                 Name { namespace = "Soup" , name = "MultipartInputStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMultipartInputStream."
--                 , 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 "a #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_multipart_input_stream_next_part_finish" soup_multipart_input_stream_next_part_finish :: 
    Ptr MultipartInputStream ->             -- multipart : TInterface (Name {namespace = "Soup", name = "MultipartInputStream"})
    Ptr Gio.AsyncResult.AsyncResult ->      -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
    Ptr (Ptr GError) ->                     -- error
    IO (Ptr Gio.InputStream.InputStream)

-- | Finishes an asynchronous request for the next part.
-- 
-- /Since: 2.40/
multipartInputStreamNextPartFinish ::
    (B.CallStack.HasCallStack, MonadIO m, IsMultipartInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
    a
    -- ^ /@multipart@/: a t'GI.Soup.Objects.MultipartInputStream.MultipartInputStream'.
    -> b
    -- ^ /@result@/: a t'GI.Gio.Interfaces.AsyncResult.AsyncResult'.
    -> m (Maybe Gio.InputStream.InputStream)
    -- ^ __Returns:__ a newly created
    -- t'GI.Gio.Objects.InputStream.InputStream' for reading the next part or 'P.Nothing' if there are no
    -- more parts. /(Can throw 'Data.GI.Base.GError.GError')/
multipartInputStreamNextPartFinish :: a -> b -> m (Maybe InputStream)
multipartInputStreamNextPartFinish a
multipart b
result_ = IO (Maybe InputStream) -> m (Maybe InputStream)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStream) -> m (Maybe InputStream))
-> IO (Maybe InputStream) -> m (Maybe InputStream)
forall a b. (a -> b) -> a -> b
$ do
    Ptr MultipartInputStream
multipart' <- a -> IO (Ptr MultipartInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
multipart
    Ptr AsyncResult
result_' <- b -> IO (Ptr AsyncResult)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
    IO (Maybe InputStream) -> IO () -> IO (Maybe InputStream)
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr InputStream
result <- (Ptr (Ptr GError) -> IO (Ptr InputStream)) -> IO (Ptr InputStream)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr InputStream))
 -> IO (Ptr InputStream))
-> (Ptr (Ptr GError) -> IO (Ptr InputStream))
-> IO (Ptr InputStream)
forall a b. (a -> b) -> a -> b
$ Ptr MultipartInputStream
-> Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr InputStream)
soup_multipart_input_stream_next_part_finish Ptr MultipartInputStream
multipart' Ptr AsyncResult
result_'
        Maybe InputStream
maybeResult <- Ptr InputStream
-> (Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr InputStream
result ((Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream))
-> (Ptr InputStream -> IO InputStream) -> IO (Maybe InputStream)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStream
result' -> do
            InputStream
result'' <- ((ManagedPtr InputStream -> InputStream)
-> Ptr InputStream -> IO InputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr InputStream -> InputStream
Gio.InputStream.InputStream) Ptr InputStream
result'
            InputStream -> IO InputStream
forall (m :: * -> *) a. Monad m => a -> m a
return InputStream
result''
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
multipart
        b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
        Maybe InputStream -> IO (Maybe InputStream)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStream
maybeResult
     ) (do
        () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     )

#if defined(ENABLE_OVERLOADING)
data MultipartInputStreamNextPartFinishMethodInfo
instance (signature ~ (b -> m (Maybe Gio.InputStream.InputStream)), MonadIO m, IsMultipartInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo MultipartInputStreamNextPartFinishMethodInfo a signature where
    overloadedMethod = multipartInputStreamNextPartFinish

#endif