MessageBody.hs


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

A 'GI.Soup.Objects.Message.Message' request or response body.

Note that while /@length@/ always reflects the full length of the
message body, /@data@/ is normally 'Nothing', and will only be filled in
after 'GI.Soup.Structs.MessageBody.messageBodyFlatten' is called. For client-side
messages, this automatically happens for the response body after it
has been fully read, unless you set the
'GI.Soup.Flags.MessageFlagsOverwriteChunks' flags. Likewise, for server-side
messages, the request body is automatically filled in after being
read.

As an added bonus, when /@data@/ is filled in, it is always terminated
with a \'\\0\' byte (which is not reflected in /@length@/).
-}

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

module GI.Soup.Structs.MessageBody
    ( 

-- * Exported types
    MessageBody(..)                         ,
    newZeroMessageBody                      ,
    noMessageBody                           ,


 -- * Methods
-- ** append #method:append#

#if ENABLE_OVERLOADING
    MessageBodyAppendMethodInfo             ,
#endif
    messageBodyAppend                       ,


-- ** appendBuffer #method:appendBuffer#

#if ENABLE_OVERLOADING
    MessageBodyAppendBufferMethodInfo       ,
#endif
    messageBodyAppendBuffer                 ,


-- ** complete #method:complete#

#if ENABLE_OVERLOADING
    MessageBodyCompleteMethodInfo           ,
#endif
    messageBodyComplete                     ,


-- ** flatten #method:flatten#

#if ENABLE_OVERLOADING
    MessageBodyFlattenMethodInfo            ,
#endif
    messageBodyFlatten                      ,


-- ** free #method:free#

#if ENABLE_OVERLOADING
    MessageBodyFreeMethodInfo               ,
#endif
    messageBodyFree                         ,


-- ** getAccumulate #method:getAccumulate#

#if ENABLE_OVERLOADING
    MessageBodyGetAccumulateMethodInfo      ,
#endif
    messageBodyGetAccumulate                ,


-- ** getChunk #method:getChunk#

#if ENABLE_OVERLOADING
    MessageBodyGetChunkMethodInfo           ,
#endif
    messageBodyGetChunk                     ,


-- ** gotChunk #method:gotChunk#

#if ENABLE_OVERLOADING
    MessageBodyGotChunkMethodInfo           ,
#endif
    messageBodyGotChunk                     ,


-- ** new #method:new#

    messageBodyNew                          ,


-- ** setAccumulate #method:setAccumulate#

#if ENABLE_OVERLOADING
    MessageBodySetAccumulateMethodInfo      ,
#endif
    messageBodySetAccumulate                ,


-- ** truncate #method:truncate#

#if ENABLE_OVERLOADING
    MessageBodyTruncateMethodInfo           ,
#endif
    messageBodyTruncate                     ,


-- ** wroteChunk #method:wroteChunk#

#if ENABLE_OVERLOADING
    MessageBodyWroteChunkMethodInfo         ,
#endif
    messageBodyWroteChunk                   ,




 -- * Properties
-- ** data #attr:data#
{- | the data
-}
    clearMessageBodyData                    ,
    getMessageBodyData                      ,
#if ENABLE_OVERLOADING
    messageBody_data                        ,
#endif
    setMessageBodyData                      ,


-- ** length #attr:length#
{- | length of /@data@/
-}
    getMessageBodyLength                    ,
#if ENABLE_OVERLOADING
    messageBody_length                      ,
#endif
    setMessageBodyLength                    ,




    ) 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.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.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 {-# SOURCE #-} qualified GI.Soup.Structs.Buffer as Soup.Buffer

-- | Memory-managed wrapper type.
newtype MessageBody = MessageBody (ManagedPtr MessageBody)
foreign import ccall "soup_message_body_get_type" c_soup_message_body_get_type :: 
    IO GType

instance BoxedObject MessageBody where
    boxedType _ = c_soup_message_body_get_type

-- | Construct a `MessageBody` struct initialized to zero.
newZeroMessageBody :: MonadIO m => m MessageBody
newZeroMessageBody = liftIO $ callocBoxedBytes 16 >>= wrapBoxed MessageBody

instance tag ~ 'AttrSet => Constructible MessageBody tag where
    new _ attrs = do
        o <- newZeroMessageBody
        GI.Attributes.set o attrs
        return o


-- | A convenience alias for `Nothing` :: `Maybe` `MessageBody`.
noMessageBody :: Maybe MessageBody
noMessageBody = Nothing

{- |
Get the value of the “@data@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' messageBody #data
@
-}
getMessageBodyData :: MonadIO m => MessageBody -> m (Maybe T.Text)
getMessageBodyData s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    result <- SP.convertIfNonNull val $ \val' -> do
        val'' <- cstringToText val'
        return val''
    return result

{- |
Set the value of the “@data@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' messageBody [ #data 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMessageBodyData :: MonadIO m => MessageBody -> CString -> m ()
setMessageBodyData s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (val :: CString)

{- |
Set the value of the “@data@” field to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.clear' #data
@
-}
clearMessageBodyData :: MonadIO m => MessageBody -> m ()
clearMessageBodyData s = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 0) (FP.nullPtr :: CString)

#if ENABLE_OVERLOADING
data MessageBodyDataFieldInfo
instance AttrInfo MessageBodyDataFieldInfo where
    type AttrAllowedOps MessageBodyDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint MessageBodyDataFieldInfo = (~) CString
    type AttrBaseTypeConstraint MessageBodyDataFieldInfo = (~) MessageBody
    type AttrGetType MessageBodyDataFieldInfo = Maybe T.Text
    type AttrLabel MessageBodyDataFieldInfo = "data"
    type AttrOrigin MessageBodyDataFieldInfo = MessageBody
    attrGet _ = getMessageBodyData
    attrSet _ = setMessageBodyData
    attrConstruct = undefined
    attrClear _ = clearMessageBodyData

messageBody_data :: AttrLabelProxy "data"
messageBody_data = AttrLabelProxy

#endif


{- |
Get the value of the “@length@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' messageBody #length
@
-}
getMessageBodyLength :: MonadIO m => MessageBody -> m Int64
getMessageBodyLength s = liftIO $ withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 8) :: IO Int64
    return val

{- |
Set the value of the “@length@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' messageBody [ #length 'Data.GI.Base.Attributes.:=' value ]
@
-}
setMessageBodyLength :: MonadIO m => MessageBody -> Int64 -> m ()
setMessageBodyLength s val = liftIO $ withManagedPtr s $ \ptr -> do
    poke (ptr `plusPtr` 8) (val :: Int64)

#if ENABLE_OVERLOADING
data MessageBodyLengthFieldInfo
instance AttrInfo MessageBodyLengthFieldInfo where
    type AttrAllowedOps MessageBodyLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
    type AttrSetTypeConstraint MessageBodyLengthFieldInfo = (~) Int64
    type AttrBaseTypeConstraint MessageBodyLengthFieldInfo = (~) MessageBody
    type AttrGetType MessageBodyLengthFieldInfo = Int64
    type AttrLabel MessageBodyLengthFieldInfo = "length"
    type AttrOrigin MessageBodyLengthFieldInfo = MessageBody
    attrGet _ = getMessageBodyLength
    attrSet _ = setMessageBodyLength
    attrConstruct = undefined
    attrClear _ = undefined

messageBody_length :: AttrLabelProxy "length"
messageBody_length = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList MessageBody
type instance O.AttributeList MessageBody = MessageBodyAttributeList
type MessageBodyAttributeList = ('[ '("data", MessageBodyDataFieldInfo), '("length", MessageBodyLengthFieldInfo)] :: [(Symbol, *)])
#endif

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

foreign import ccall "soup_message_body_new" soup_message_body_new :: 
    IO (Ptr MessageBody)

{- |
Creates a new 'GI.Soup.Structs.MessageBody.MessageBody'. 'GI.Soup.Objects.Message.Message' uses this internally; you
will not normally need to call it yourself.
-}
messageBodyNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m MessageBody
    {- ^ __Returns:__ a new 'GI.Soup.Structs.MessageBody.MessageBody'. -}
messageBodyNew  = liftIO $ do
    result <- soup_message_body_new
    checkUnexpectedReturnNULL "messageBodyNew" result
    result' <- (wrapBoxed MessageBody) result
    return result'

#if ENABLE_OVERLOADING
#endif

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

foreign import ccall "soup_message_body_append_buffer" soup_message_body_append_buffer :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    Ptr Soup.Buffer.Buffer ->               -- buffer : TInterface (Name {namespace = "Soup", name = "Buffer"})
    IO ()

{- |
Appends the data from /@buffer@/ to /@body@/. ('GI.Soup.Structs.MessageBody.MessageBody' uses
@/SoupBuffers/@ internally, so this is normally a constant-time
operation that doesn\'t actually require copying the data in
/@buffer@/.)
-}
messageBodyAppendBuffer ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> Soup.Buffer.Buffer
    {- ^ /@buffer@/: a 'GI.Soup.Structs.Buffer.Buffer' -}
    -> m ()
messageBodyAppendBuffer body buffer = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    buffer' <- unsafeManagedPtrGetPtr buffer
    soup_message_body_append_buffer body' buffer'
    touchManagedPtr body
    touchManagedPtr buffer
    return ()

#if ENABLE_OVERLOADING
data MessageBodyAppendBufferMethodInfo
instance (signature ~ (Soup.Buffer.Buffer -> m ()), MonadIO m) => O.MethodInfo MessageBodyAppendBufferMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyAppendBuffer

#endif

-- method MessageBody::append
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "body", argType = TInterface (Name {namespace = "Soup", name = "MessageBody"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageBody", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "data to append", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_body_append_take" soup_message_body_append_take :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    Ptr Word8 ->                            -- data : TCArray False (-1) 2 (TBasicType TUInt8)
    Word64 ->                               -- length : TBasicType TUInt64
    IO ()

{- |
Appends /@length@/ bytes from /@data@/ to /@body@/.

This function is exactly equivalent to @/soup_message_body_append()/@
with 'GI.Soup.Enums.MemoryUseTake' as second argument; it exists mainly for
convenience and simplifying language bindings.

/Since: 2.32/
-}
messageBodyAppend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> ByteString
    {- ^ /@data@/: data to append -}
    -> m ()
messageBodyAppend body data_ = liftIO $ do
    let length_ = fromIntegral $ B.length data_
    body' <- unsafeManagedPtrGetPtr body
    data_' <- packByteString data_
    soup_message_body_append_take body' data_' length_
    touchManagedPtr body
    return ()

#if ENABLE_OVERLOADING
data MessageBodyAppendMethodInfo
instance (signature ~ (ByteString -> m ()), MonadIO m) => O.MethodInfo MessageBodyAppendMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyAppend

#endif

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

foreign import ccall "soup_message_body_complete" soup_message_body_complete :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    IO ()

{- |
Tags /@body@/ as being complete; Call this when using chunked encoding
after you have appended the last chunk.
-}
messageBodyComplete ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> m ()
messageBodyComplete body = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    soup_message_body_complete body'
    touchManagedPtr body
    return ()

#if ENABLE_OVERLOADING
data MessageBodyCompleteMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageBodyCompleteMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyComplete

#endif

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

foreign import ccall "soup_message_body_flatten" soup_message_body_flatten :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    IO (Ptr Soup.Buffer.Buffer)

{- |
Fills in /@body@/\'s data field with a buffer containing all of the
data in /@body@/ (plus an additional \'\\0\' byte not counted by /@body@/\'s
length field).
-}
messageBodyFlatten ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> m Soup.Buffer.Buffer
    {- ^ __Returns:__ a 'GI.Soup.Structs.Buffer.Buffer' containing the same data as /@body@/.
(You must free this buffer if you do not want it.) -}
messageBodyFlatten body = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    result <- soup_message_body_flatten body'
    checkUnexpectedReturnNULL "messageBodyFlatten" result
    result' <- (wrapBoxed Soup.Buffer.Buffer) result
    touchManagedPtr body
    return result'

#if ENABLE_OVERLOADING
data MessageBodyFlattenMethodInfo
instance (signature ~ (m Soup.Buffer.Buffer), MonadIO m) => O.MethodInfo MessageBodyFlattenMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyFlatten

#endif

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

foreign import ccall "soup_message_body_free" soup_message_body_free :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    IO ()

{- |
Frees /@body@/. You will not normally need to use this, as
'GI.Soup.Objects.Message.Message' frees its associated message bodies automatically.
-}
messageBodyFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> m ()
messageBodyFree body = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    soup_message_body_free body'
    touchManagedPtr body
    return ()

#if ENABLE_OVERLOADING
data MessageBodyFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageBodyFreeMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyFree

#endif

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

foreign import ccall "soup_message_body_get_accumulate" soup_message_body_get_accumulate :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    IO CInt

{- |
Gets the accumulate flag on /@body@/; see
'GI.Soup.Structs.MessageBody.messageBodySetAccumulate' for details.

/Since: 2.24/
-}
messageBodyGetAccumulate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> m Bool
    {- ^ __Returns:__ the accumulate flag for /@body@/. -}
messageBodyGetAccumulate body = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    result <- soup_message_body_get_accumulate body'
    let result' = (/= 0) result
    touchManagedPtr body
    return result'

#if ENABLE_OVERLOADING
data MessageBodyGetAccumulateMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo MessageBodyGetAccumulateMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyGetAccumulate

#endif

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

foreign import ccall "soup_message_body_get_chunk" soup_message_body_get_chunk :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    Int64 ->                                -- offset : TBasicType TInt64
    IO (Ptr Soup.Buffer.Buffer)

{- |
Gets a 'GI.Soup.Structs.Buffer.Buffer' containing data from /@body@/ starting at /@offset@/.
The size of the returned chunk is unspecified. You can iterate
through the entire body by first calling
'GI.Soup.Structs.MessageBody.messageBodyGetChunk' with an offset of 0, and then on each
successive call, increment the offset by the length of the
previously-returned chunk.

If /@offset@/ is greater than or equal to the total length of /@body@/,
then the return value depends on whether or not
'GI.Soup.Structs.MessageBody.messageBodyComplete' has been called or not; if it has,
then 'GI.Soup.Structs.MessageBody.messageBodyGetChunk' will return a 0-length chunk
(indicating the end of /@body@/). If it has not, then
'GI.Soup.Structs.MessageBody.messageBodyGetChunk' will return 'Nothing' (indicating that
/@body@/ may still potentially have more data, but that data is not
currently available).
-}
messageBodyGetChunk ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> Int64
    {- ^ /@offset@/: an offset -}
    -> m (Maybe Soup.Buffer.Buffer)
    {- ^ __Returns:__ a 'GI.Soup.Structs.Buffer.Buffer', or 'Nothing'. -}
messageBodyGetChunk body offset = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    result <- soup_message_body_get_chunk body' offset
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- (wrapBoxed Soup.Buffer.Buffer) result'
        return result''
    touchManagedPtr body
    return maybeResult

#if ENABLE_OVERLOADING
data MessageBodyGetChunkMethodInfo
instance (signature ~ (Int64 -> m (Maybe Soup.Buffer.Buffer)), MonadIO m) => O.MethodInfo MessageBodyGetChunkMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyGetChunk

#endif

-- method MessageBody::got_chunk
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "body", argType = TInterface (Name {namespace = "Soup", name = "MessageBody"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageBody", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chunk", argType = TInterface (Name {namespace = "Soup", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupBuffer received from the network", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_body_got_chunk" soup_message_body_got_chunk :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    Ptr Soup.Buffer.Buffer ->               -- chunk : TInterface (Name {namespace = "Soup", name = "Buffer"})
    IO ()

{- |
Handles the 'GI.Soup.Structs.MessageBody.MessageBody' part of receiving a chunk of data from
the network. Normally this means appending /@chunk@/ to /@body@/, exactly
as with 'GI.Soup.Structs.MessageBody.messageBodyAppendBuffer', but if you have set
/@body@/\'s accumulate flag to 'False', then that will not happen.

This is a low-level method which you should not normally need to
use.

/Since: 2.24/
-}
messageBodyGotChunk ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> Soup.Buffer.Buffer
    {- ^ /@chunk@/: a 'GI.Soup.Structs.Buffer.Buffer' received from the network -}
    -> m ()
messageBodyGotChunk body chunk = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    chunk' <- unsafeManagedPtrGetPtr chunk
    soup_message_body_got_chunk body' chunk'
    touchManagedPtr body
    touchManagedPtr chunk
    return ()

#if ENABLE_OVERLOADING
data MessageBodyGotChunkMethodInfo
instance (signature ~ (Soup.Buffer.Buffer -> m ()), MonadIO m) => O.MethodInfo MessageBodyGotChunkMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyGotChunk

#endif

-- method MessageBody::set_accumulate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "body", argType = TInterface (Name {namespace = "Soup", name = "MessageBody"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageBody", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "accumulate", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not to accumulate body chunks in @body", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_body_set_accumulate" soup_message_body_set_accumulate :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    CInt ->                                 -- accumulate : TBasicType TBoolean
    IO ()

{- |
Sets or clears the accumulate flag on /@body@/. (The default value is
'True'.) If set to 'False', /@body@/\'s @/data/@ field will not be filled in
after the body is fully sent\/received, and the chunks that make up
/@body@/ may be discarded when they are no longer needed.

In particular, if you set this flag to 'False' on an \"incoming\"
message body (that is, the 'GI.Soup.Objects.Message.Message':@/response_body/@ of a
client-side message, or 'GI.Soup.Objects.Message.Message':@/request_body/@ of a server-side
message), this will cause each chunk of the body to be discarded
after its corresponding 'GI.Soup.Objects.Message.Message'::@/got_chunk/@ signal is emitted.
(This is equivalent to setting the deprecated
'GI.Soup.Flags.MessageFlagsOverwriteChunks' flag on the message.)

If you set this flag to 'False' on the 'GI.Soup.Objects.Message.Message':@/response_body/@ of
a server-side message, it will cause each chunk of the body to be
discarded after its corresponding 'GI.Soup.Objects.Message.Message'::@/wrote_chunk/@ signal
is emitted.

If you set the flag to 'False' on the 'GI.Soup.Objects.Message.Message':@/request_body/@ of a
client-side message, it will block the accumulation of chunks into
/@body@/\'s @/data/@ field, but it will not normally cause the chunks to
be discarded after being written like in the server-side
'GI.Soup.Objects.Message.Message':@/response_body/@ case, because the request body needs to
be kept around in case the request needs to be sent a second time
due to redirection or authentication. However, if you set the
'GI.Soup.Flags.MessageFlagsCanRebuild' flag on the message, then the chunks will
be discarded, and you will be responsible for recreating the
request body after the 'GI.Soup.Objects.Message.Message'::@/restarted/@ signal is emitted.

/Since: 2.24/
-}
messageBodySetAccumulate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> Bool
    {- ^ /@accumulate@/: whether or not to accumulate body chunks in /@body@/ -}
    -> m ()
messageBodySetAccumulate body accumulate = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    let accumulate' = (fromIntegral . fromEnum) accumulate
    soup_message_body_set_accumulate body' accumulate'
    touchManagedPtr body
    return ()

#if ENABLE_OVERLOADING
data MessageBodySetAccumulateMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo MessageBodySetAccumulateMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodySetAccumulate

#endif

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

foreign import ccall "soup_message_body_truncate" soup_message_body_truncate :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    IO ()

{- |
Deletes all of the data in /@body@/.
-}
messageBodyTruncate ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> m ()
messageBodyTruncate body = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    soup_message_body_truncate body'
    touchManagedPtr body
    return ()

#if ENABLE_OVERLOADING
data MessageBodyTruncateMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageBodyTruncateMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyTruncate

#endif

-- method MessageBody::wrote_chunk
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "body", argType = TInterface (Name {namespace = "Soup", name = "MessageBody"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupMessageBody", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "chunk", argType = TInterface (Name {namespace = "Soup", name = "Buffer"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #SoupBuffer returned from soup_message_body_get_chunk()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_body_wrote_chunk" soup_message_body_wrote_chunk :: 
    Ptr MessageBody ->                      -- body : TInterface (Name {namespace = "Soup", name = "MessageBody"})
    Ptr Soup.Buffer.Buffer ->               -- chunk : TInterface (Name {namespace = "Soup", name = "Buffer"})
    IO ()

{- |
Handles the 'GI.Soup.Structs.MessageBody.MessageBody' part of writing a chunk of data to the
network. Normally this is a no-op, but if you have set /@body@/\'s
accumulate flag to 'False', then this will cause /@chunk@/ to be
discarded to free up memory.

This is a low-level method which you should not need to use, and
there are further restrictions on its proper use which are not
documented here.

/Since: 2.24/
-}
messageBodyWroteChunk ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageBody
    {- ^ /@body@/: a 'GI.Soup.Structs.MessageBody.MessageBody' -}
    -> Soup.Buffer.Buffer
    {- ^ /@chunk@/: a 'GI.Soup.Structs.Buffer.Buffer' returned from 'GI.Soup.Structs.MessageBody.messageBodyGetChunk' -}
    -> m ()
messageBodyWroteChunk body chunk = liftIO $ do
    body' <- unsafeManagedPtrGetPtr body
    chunk' <- unsafeManagedPtrGetPtr chunk
    soup_message_body_wrote_chunk body' chunk'
    touchManagedPtr body
    touchManagedPtr chunk
    return ()

#if ENABLE_OVERLOADING
data MessageBodyWroteChunkMethodInfo
instance (signature ~ (Soup.Buffer.Buffer -> m ()), MonadIO m) => O.MethodInfo MessageBodyWroteChunkMethodInfo MessageBody signature where
    overloadedMethod _ = messageBodyWroteChunk

#endif

#if ENABLE_OVERLOADING
type family ResolveMessageBodyMethod (t :: Symbol) (o :: *) :: * where
    ResolveMessageBodyMethod "appendBuffer" o = MessageBodyAppendBufferMethodInfo
    ResolveMessageBodyMethod "append" o = MessageBodyAppendMethodInfo
    ResolveMessageBodyMethod "complete" o = MessageBodyCompleteMethodInfo
    ResolveMessageBodyMethod "flatten" o = MessageBodyFlattenMethodInfo
    ResolveMessageBodyMethod "free" o = MessageBodyFreeMethodInfo
    ResolveMessageBodyMethod "gotChunk" o = MessageBodyGotChunkMethodInfo
    ResolveMessageBodyMethod "truncate" o = MessageBodyTruncateMethodInfo
    ResolveMessageBodyMethod "wroteChunk" o = MessageBodyWroteChunkMethodInfo
    ResolveMessageBodyMethod "getAccumulate" o = MessageBodyGetAccumulateMethodInfo
    ResolveMessageBodyMethod "getChunk" o = MessageBodyGetChunkMethodInfo
    ResolveMessageBodyMethod "setAccumulate" o = MessageBodySetAccumulateMethodInfo
    ResolveMessageBodyMethod l o = O.MethodResolutionFailed l o

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

#endif