{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Structs.MessageBody
(
MessageBody(..) ,
newZeroMessageBody ,
#if defined(ENABLE_OVERLOADING)
ResolveMessageBodyMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MessageBodyAppendMethodInfo ,
#endif
messageBodyAppend ,
#if defined(ENABLE_OVERLOADING)
MessageBodyAppendBufferMethodInfo ,
#endif
messageBodyAppendBuffer ,
#if defined(ENABLE_OVERLOADING)
MessageBodyCompleteMethodInfo ,
#endif
messageBodyComplete ,
#if defined(ENABLE_OVERLOADING)
MessageBodyFlattenMethodInfo ,
#endif
messageBodyFlatten ,
#if defined(ENABLE_OVERLOADING)
MessageBodyFreeMethodInfo ,
#endif
messageBodyFree ,
#if defined(ENABLE_OVERLOADING)
MessageBodyGetAccumulateMethodInfo ,
#endif
messageBodyGetAccumulate ,
#if defined(ENABLE_OVERLOADING)
MessageBodyGetChunkMethodInfo ,
#endif
messageBodyGetChunk ,
#if defined(ENABLE_OVERLOADING)
MessageBodyGotChunkMethodInfo ,
#endif
messageBodyGotChunk ,
messageBodyNew ,
#if defined(ENABLE_OVERLOADING)
MessageBodySetAccumulateMethodInfo ,
#endif
messageBodySetAccumulate ,
#if defined(ENABLE_OVERLOADING)
MessageBodyTruncateMethodInfo ,
#endif
messageBodyTruncate ,
#if defined(ENABLE_OVERLOADING)
MessageBodyWroteChunkMethodInfo ,
#endif
messageBodyWroteChunk ,
clearMessageBodyData ,
getMessageBodyData ,
#if defined(ENABLE_OVERLOADING)
messageBody_data ,
#endif
setMessageBodyData ,
getMessageBodyLength ,
#if defined(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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.Soup.Structs.Buffer as Soup.Buffer
newtype MessageBody = MessageBody (SP.ManagedPtr MessageBody)
deriving (MessageBody -> MessageBody -> Bool
(MessageBody -> MessageBody -> Bool)
-> (MessageBody -> MessageBody -> Bool) -> Eq MessageBody
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MessageBody -> MessageBody -> Bool
$c/= :: MessageBody -> MessageBody -> Bool
== :: MessageBody -> MessageBody -> Bool
$c== :: MessageBody -> MessageBody -> Bool
Eq)
instance SP.ManagedPtrNewtype MessageBody where
toManagedPtr :: MessageBody -> ManagedPtr MessageBody
toManagedPtr (MessageBody ManagedPtr MessageBody
p) = ManagedPtr MessageBody
p
foreign import ccall "soup_message_body_get_type" c_soup_message_body_get_type ::
IO GType
type instance O.ParentTypes MessageBody = '[]
instance O.HasParentTypes MessageBody
instance B.Types.TypedObject MessageBody where
glibType :: IO GType
glibType = IO GType
c_soup_message_body_get_type
instance B.Types.GBoxed MessageBody
instance B.GValue.IsGValue (Maybe MessageBody) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_message_body_get_type
gvalueSet_ :: Ptr GValue -> Maybe MessageBody -> IO ()
gvalueSet_ Ptr GValue
gv Maybe MessageBody
P.Nothing = Ptr GValue -> Ptr MessageBody -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr MessageBody
forall a. Ptr a
FP.nullPtr :: FP.Ptr MessageBody)
gvalueSet_ Ptr GValue
gv (P.Just MessageBody
obj) = MessageBody -> (Ptr MessageBody -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MessageBody
obj (Ptr GValue -> Ptr MessageBody -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe MessageBody)
gvalueGet_ Ptr GValue
gv = do
Ptr MessageBody
ptr <- Ptr GValue -> IO (Ptr MessageBody)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr MessageBody)
if Ptr MessageBody
ptr Ptr MessageBody -> Ptr MessageBody -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr MessageBody
forall a. Ptr a
FP.nullPtr
then MessageBody -> Maybe MessageBody
forall a. a -> Maybe a
P.Just (MessageBody -> Maybe MessageBody)
-> IO MessageBody -> IO (Maybe MessageBody)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr MessageBody -> MessageBody)
-> Ptr MessageBody -> IO MessageBody
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr MessageBody -> MessageBody
MessageBody Ptr MessageBody
ptr
else Maybe MessageBody -> IO (Maybe MessageBody)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MessageBody
forall a. Maybe a
P.Nothing
newZeroMessageBody :: MonadIO m => m MessageBody
newZeroMessageBody :: forall (m :: * -> *). MonadIO m => m MessageBody
newZeroMessageBody = IO MessageBody -> m MessageBody
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageBody -> m MessageBody)
-> IO MessageBody -> m MessageBody
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr MessageBody)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
16 IO (Ptr MessageBody)
-> (Ptr MessageBody -> IO MessageBody) -> IO MessageBody
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr MessageBody -> MessageBody)
-> Ptr MessageBody -> IO MessageBody
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MessageBody -> MessageBody
MessageBody
instance tag ~ 'AttrSet => Constructible MessageBody tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr MessageBody -> MessageBody)
-> [AttrOp MessageBody tag] -> m MessageBody
new ManagedPtr MessageBody -> MessageBody
_ [AttrOp MessageBody tag]
attrs = do
MessageBody
o <- m MessageBody
forall (m :: * -> *). MonadIO m => m MessageBody
newZeroMessageBody
MessageBody -> [AttrOp MessageBody 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set MessageBody
o [AttrOp MessageBody tag]
[AttrOp MessageBody 'AttrSet]
attrs
MessageBody -> m MessageBody
forall (m :: * -> *) a. Monad m => a -> m a
return MessageBody
o
getMessageBodyData :: MonadIO m => MessageBody -> m (Maybe T.Text)
getMessageBodyData :: forall (m :: * -> *). MonadIO m => MessageBody -> m (Maybe Text)
getMessageBodyData MessageBody
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ MessageBody
-> (Ptr MessageBody -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MessageBody
s ((Ptr MessageBody -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr MessageBody -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr MessageBody
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr MessageBody
ptr Ptr MessageBody -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setMessageBodyData :: MonadIO m => MessageBody -> CString -> m ()
setMessageBodyData :: forall (m :: * -> *). MonadIO m => MessageBody -> CString -> m ()
setMessageBodyData MessageBody
s CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MessageBody -> (Ptr MessageBody -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MessageBody
s ((Ptr MessageBody -> IO ()) -> IO ())
-> (Ptr MessageBody -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr MessageBody
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MessageBody
ptr Ptr MessageBody -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
val :: CString)
clearMessageBodyData :: MonadIO m => MessageBody -> m ()
clearMessageBodyData :: forall (m :: * -> *). MonadIO m => MessageBody -> m ()
clearMessageBodyData MessageBody
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MessageBody -> (Ptr MessageBody -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MessageBody
s ((Ptr MessageBody -> IO ()) -> IO ())
-> (Ptr MessageBody -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr MessageBody
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MessageBody
ptr Ptr MessageBody -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data MessageBodyDataFieldInfo
instance AttrInfo MessageBodyDataFieldInfo where
type AttrBaseTypeConstraint MessageBodyDataFieldInfo = (~) MessageBody
type AttrAllowedOps MessageBodyDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageBodyDataFieldInfo = (~) CString
type AttrTransferTypeConstraint MessageBodyDataFieldInfo = (~)CString
type AttrTransferType MessageBodyDataFieldInfo = CString
type AttrGetType MessageBodyDataFieldInfo = Maybe T.Text
type AttrLabel MessageBodyDataFieldInfo = "data"
type AttrOrigin MessageBodyDataFieldInfo = MessageBody
attrGet = getMessageBodyData
attrSet = setMessageBodyData
attrConstruct = undefined
attrClear = clearMessageBodyData
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.data"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#g:attr:data"
})
messageBody_data :: AttrLabelProxy "data"
messageBody_data = AttrLabelProxy
#endif
getMessageBodyLength :: MonadIO m => MessageBody -> m Int64
getMessageBodyLength :: forall (m :: * -> *). MonadIO m => MessageBody -> m Int64
getMessageBodyLength MessageBody
s = IO Int64 -> m Int64
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ MessageBody -> (Ptr MessageBody -> IO Int64) -> IO Int64
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MessageBody
s ((Ptr MessageBody -> IO Int64) -> IO Int64)
-> (Ptr MessageBody -> IO Int64) -> IO Int64
forall a b. (a -> b) -> a -> b
$ \Ptr MessageBody
ptr -> do
Int64
val <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek (Ptr MessageBody
ptr Ptr MessageBody -> Int -> Ptr Int64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO Int64
Int64 -> IO Int64
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
val
setMessageBodyLength :: MonadIO m => MessageBody -> Int64 -> m ()
setMessageBodyLength :: forall (m :: * -> *). MonadIO m => MessageBody -> Int64 -> m ()
setMessageBodyLength MessageBody
s Int64
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MessageBody -> (Ptr MessageBody -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MessageBody
s ((Ptr MessageBody -> IO ()) -> IO ())
-> (Ptr MessageBody -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr MessageBody
ptr -> do
Ptr Int64 -> Int64 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MessageBody
ptr Ptr MessageBody -> Int -> Ptr Int64
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Int64
val :: Int64)
#if defined(ENABLE_OVERLOADING)
data MessageBodyLengthFieldInfo
instance AttrInfo MessageBodyLengthFieldInfo where
type AttrBaseTypeConstraint MessageBodyLengthFieldInfo = (~) MessageBody
type AttrAllowedOps MessageBodyLengthFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint MessageBodyLengthFieldInfo = (~) Int64
type AttrTransferTypeConstraint MessageBodyLengthFieldInfo = (~)Int64
type AttrTransferType MessageBodyLengthFieldInfo = Int64
type AttrGetType MessageBodyLengthFieldInfo = Int64
type AttrLabel MessageBodyLengthFieldInfo = "length"
type AttrOrigin MessageBodyLengthFieldInfo = MessageBody
attrGet = getMessageBodyLength
attrSet = setMessageBodyLength
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.length"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#g:attr:length"
})
messageBody_length :: AttrLabelProxy "length"
messageBody_length = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MessageBody
type instance O.AttributeList MessageBody = MessageBodyAttributeList
type MessageBodyAttributeList = ('[ '("data", MessageBodyDataFieldInfo), '("length", MessageBodyLengthFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_message_body_new" soup_message_body_new ::
IO (Ptr MessageBody)
messageBodyNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m MessageBody
messageBodyNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m MessageBody
messageBodyNew = IO MessageBody -> m MessageBody
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageBody -> m MessageBody)
-> IO MessageBody -> m MessageBody
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageBody
result <- IO (Ptr MessageBody)
soup_message_body_new
Text -> Ptr MessageBody -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageBodyNew" Ptr MessageBody
result
MessageBody
result' <- ((ManagedPtr MessageBody -> MessageBody)
-> Ptr MessageBody -> IO MessageBody
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MessageBody -> MessageBody
MessageBody) Ptr MessageBody
result
MessageBody -> IO MessageBody
forall (m :: * -> *) a. Monad m => a -> m a
return MessageBody
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_message_body_append_buffer" soup_message_body_append_buffer ::
Ptr MessageBody ->
Ptr Soup.Buffer.Buffer ->
IO ()
messageBodyAppendBuffer ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> Soup.Buffer.Buffer
-> m ()
messageBodyAppendBuffer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> Buffer -> m ()
messageBodyAppendBuffer MessageBody
body Buffer
buffer = 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 MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr Buffer
buffer' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
buffer
Ptr MessageBody -> Ptr Buffer -> IO ()
soup_message_body_append_buffer Ptr MessageBody
body' Ptr Buffer
buffer'
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
buffer
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageBodyAppendBufferMethodInfo
instance (signature ~ (Soup.Buffer.Buffer -> m ()), MonadIO m) => O.OverloadedMethod MessageBodyAppendBufferMethodInfo MessageBody signature where
overloadedMethod = messageBodyAppendBuffer
instance O.OverloadedMethodInfo MessageBodyAppendBufferMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyAppendBuffer",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyAppendBuffer"
})
#endif
foreign import ccall "soup_message_body_append_take" soup_message_body_append_take ::
Ptr MessageBody ->
Ptr Word8 ->
Word64 ->
IO ()
messageBodyAppend ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> ByteString
-> m ()
messageBodyAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> ByteString -> m ()
messageBodyAppend MessageBody
body ByteString
data_ = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let length_ :: Word64
length_ = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
data_
Ptr MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr Word8
data_' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
data_
Ptr MessageBody -> Ptr Word8 -> Word64 -> IO ()
soup_message_body_append_take Ptr MessageBody
body' Ptr Word8
data_' Word64
length_
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageBodyAppendMethodInfo
instance (signature ~ (ByteString -> m ()), MonadIO m) => O.OverloadedMethod MessageBodyAppendMethodInfo MessageBody signature where
overloadedMethod = messageBodyAppend
instance O.OverloadedMethodInfo MessageBodyAppendMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyAppend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyAppend"
})
#endif
foreign import ccall "soup_message_body_complete" soup_message_body_complete ::
Ptr MessageBody ->
IO ()
messageBodyComplete ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> m ()
messageBodyComplete :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> m ()
messageBodyComplete MessageBody
body = 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 MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr MessageBody -> IO ()
soup_message_body_complete Ptr MessageBody
body'
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageBodyCompleteMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MessageBodyCompleteMethodInfo MessageBody signature where
overloadedMethod = messageBodyComplete
instance O.OverloadedMethodInfo MessageBodyCompleteMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyComplete",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyComplete"
})
#endif
foreign import ccall "soup_message_body_flatten" soup_message_body_flatten ::
Ptr MessageBody ->
IO (Ptr Soup.Buffer.Buffer)
messageBodyFlatten ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> m Soup.Buffer.Buffer
messageBodyFlatten :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> m Buffer
messageBodyFlatten MessageBody
body = IO Buffer -> m Buffer
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Buffer -> m Buffer) -> IO Buffer -> m Buffer
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr Buffer
result <- Ptr MessageBody -> IO (Ptr Buffer)
soup_message_body_flatten Ptr MessageBody
body'
Text -> Ptr Buffer -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageBodyFlatten" Ptr Buffer
result
Buffer
result' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Soup.Buffer.Buffer) Ptr Buffer
result
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result'
#if defined(ENABLE_OVERLOADING)
data MessageBodyFlattenMethodInfo
instance (signature ~ (m Soup.Buffer.Buffer), MonadIO m) => O.OverloadedMethod MessageBodyFlattenMethodInfo MessageBody signature where
overloadedMethod = messageBodyFlatten
instance O.OverloadedMethodInfo MessageBodyFlattenMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyFlatten",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyFlatten"
})
#endif
foreign import ccall "soup_message_body_free" soup_message_body_free ::
Ptr MessageBody ->
IO ()
messageBodyFree ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> m ()
messageBodyFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> m ()
messageBodyFree MessageBody
body = 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 MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr MessageBody -> IO ()
soup_message_body_free Ptr MessageBody
body'
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageBodyFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MessageBodyFreeMethodInfo MessageBody signature where
overloadedMethod = messageBodyFree
instance O.OverloadedMethodInfo MessageBodyFreeMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyFree",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyFree"
})
#endif
foreign import ccall "soup_message_body_get_accumulate" soup_message_body_get_accumulate ::
Ptr MessageBody ->
IO CInt
messageBodyGetAccumulate ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> m Bool
messageBodyGetAccumulate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> m Bool
messageBodyGetAccumulate MessageBody
body = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
CInt
result <- Ptr MessageBody -> IO CInt
soup_message_body_get_accumulate Ptr MessageBody
body'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data MessageBodyGetAccumulateMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.OverloadedMethod MessageBodyGetAccumulateMethodInfo MessageBody signature where
overloadedMethod = messageBodyGetAccumulate
instance O.OverloadedMethodInfo MessageBodyGetAccumulateMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyGetAccumulate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyGetAccumulate"
})
#endif
foreign import ccall "soup_message_body_get_chunk" soup_message_body_get_chunk ::
Ptr MessageBody ->
Int64 ->
IO (Ptr Soup.Buffer.Buffer)
messageBodyGetChunk ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> Int64
-> m (Maybe Soup.Buffer.Buffer)
messageBodyGetChunk :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> Int64 -> m (Maybe Buffer)
messageBodyGetChunk MessageBody
body Int64
offset = IO (Maybe Buffer) -> m (Maybe Buffer)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Buffer) -> m (Maybe Buffer))
-> IO (Maybe Buffer) -> m (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr Buffer
result <- Ptr MessageBody -> Int64 -> IO (Ptr Buffer)
soup_message_body_get_chunk Ptr MessageBody
body' Int64
offset
Maybe Buffer
maybeResult <- Ptr Buffer -> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Buffer
result ((Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer))
-> (Ptr Buffer -> IO Buffer) -> IO (Maybe Buffer)
forall a b. (a -> b) -> a -> b
$ \Ptr Buffer
result' -> do
Buffer
result'' <- ((ManagedPtr Buffer -> Buffer) -> Ptr Buffer -> IO Buffer
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Buffer -> Buffer
Soup.Buffer.Buffer) Ptr Buffer
result'
Buffer -> IO Buffer
forall (m :: * -> *) a. Monad m => a -> m a
return Buffer
result''
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
Maybe Buffer -> IO (Maybe Buffer)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Buffer
maybeResult
#if defined(ENABLE_OVERLOADING)
data MessageBodyGetChunkMethodInfo
instance (signature ~ (Int64 -> m (Maybe Soup.Buffer.Buffer)), MonadIO m) => O.OverloadedMethod MessageBodyGetChunkMethodInfo MessageBody signature where
overloadedMethod = messageBodyGetChunk
instance O.OverloadedMethodInfo MessageBodyGetChunkMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyGetChunk",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyGetChunk"
})
#endif
foreign import ccall "soup_message_body_got_chunk" soup_message_body_got_chunk ::
Ptr MessageBody ->
Ptr Soup.Buffer.Buffer ->
IO ()
messageBodyGotChunk ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> Soup.Buffer.Buffer
-> m ()
messageBodyGotChunk :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> Buffer -> m ()
messageBodyGotChunk MessageBody
body Buffer
chunk = 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 MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr Buffer
chunk' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
chunk
Ptr MessageBody -> Ptr Buffer -> IO ()
soup_message_body_got_chunk Ptr MessageBody
body' Ptr Buffer
chunk'
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
chunk
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageBodyGotChunkMethodInfo
instance (signature ~ (Soup.Buffer.Buffer -> m ()), MonadIO m) => O.OverloadedMethod MessageBodyGotChunkMethodInfo MessageBody signature where
overloadedMethod = messageBodyGotChunk
instance O.OverloadedMethodInfo MessageBodyGotChunkMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyGotChunk",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyGotChunk"
})
#endif
foreign import ccall "soup_message_body_set_accumulate" soup_message_body_set_accumulate ::
Ptr MessageBody ->
CInt ->
IO ()
messageBodySetAccumulate ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> Bool
-> m ()
messageBodySetAccumulate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> Bool -> m ()
messageBodySetAccumulate MessageBody
body Bool
accumulate = 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 MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
let accumulate' :: CInt
accumulate' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
accumulate
Ptr MessageBody -> CInt -> IO ()
soup_message_body_set_accumulate Ptr MessageBody
body' CInt
accumulate'
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageBodySetAccumulateMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m) => O.OverloadedMethod MessageBodySetAccumulateMethodInfo MessageBody signature where
overloadedMethod = messageBodySetAccumulate
instance O.OverloadedMethodInfo MessageBodySetAccumulateMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodySetAccumulate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodySetAccumulate"
})
#endif
foreign import ccall "soup_message_body_truncate" soup_message_body_truncate ::
Ptr MessageBody ->
IO ()
messageBodyTruncate ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> m ()
messageBodyTruncate :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> m ()
messageBodyTruncate MessageBody
body = 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 MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr MessageBody -> IO ()
soup_message_body_truncate Ptr MessageBody
body'
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageBodyTruncateMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MessageBodyTruncateMethodInfo MessageBody signature where
overloadedMethod = messageBodyTruncate
instance O.OverloadedMethodInfo MessageBodyTruncateMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyTruncate",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyTruncate"
})
#endif
foreign import ccall "soup_message_body_wrote_chunk" soup_message_body_wrote_chunk ::
Ptr MessageBody ->
Ptr Soup.Buffer.Buffer ->
IO ()
messageBodyWroteChunk ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageBody
-> Soup.Buffer.Buffer
-> m ()
messageBodyWroteChunk :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageBody -> Buffer -> m ()
messageBodyWroteChunk MessageBody
body Buffer
chunk = 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 MessageBody
body' <- MessageBody -> IO (Ptr MessageBody)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageBody
body
Ptr Buffer
chunk' <- Buffer -> IO (Ptr Buffer)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Buffer
chunk
Ptr MessageBody -> Ptr Buffer -> IO ()
soup_message_body_wrote_chunk Ptr MessageBody
body' Ptr Buffer
chunk'
MessageBody -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageBody
body
Buffer -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Buffer
chunk
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageBodyWroteChunkMethodInfo
instance (signature ~ (Soup.Buffer.Buffer -> m ()), MonadIO m) => O.OverloadedMethod MessageBodyWroteChunkMethodInfo MessageBody signature where
overloadedMethod = messageBodyWroteChunk
instance O.OverloadedMethodInfo MessageBodyWroteChunkMethodInfo MessageBody where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageBody.messageBodyWroteChunk",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.25/docs/GI-Soup-Structs-MessageBody.html#v:messageBodyWroteChunk"
})
#endif
#if defined(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.OverloadedMethod info MessageBody p) => OL.IsLabel t (MessageBody -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveMessageBodyMethod t MessageBody, O.OverloadedMethod info MessageBody p, R.HasField t MessageBody p) => R.HasField t MessageBody p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMessageBodyMethod t MessageBody, O.OverloadedMethodInfo info MessageBody) => OL.IsLabel t (O.MethodProxy info MessageBody) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif