{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Structs.MessageHeaders
(
MessageHeaders(..) ,
#if defined(ENABLE_OVERLOADING)
ResolveMessageHeadersMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
MessageHeadersAppendMethodInfo ,
#endif
messageHeadersAppend ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersCleanConnectionHeadersMethodInfo,
#endif
messageHeadersCleanConnectionHeaders ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersClearMethodInfo ,
#endif
messageHeadersClear ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersForeachMethodInfo ,
#endif
messageHeadersForeach ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersFreeRangesMethodInfo ,
#endif
messageHeadersFreeRanges ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetContentDispositionMethodInfo,
#endif
messageHeadersGetContentDisposition ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetContentLengthMethodInfo,
#endif
messageHeadersGetContentLength ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetContentRangeMethodInfo ,
#endif
messageHeadersGetContentRange ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetContentTypeMethodInfo ,
#endif
messageHeadersGetContentType ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetEncodingMethodInfo ,
#endif
messageHeadersGetEncoding ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetExpectationsMethodInfo ,
#endif
messageHeadersGetExpectations ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetHeadersTypeMethodInfo ,
#endif
messageHeadersGetHeadersType ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetListMethodInfo ,
#endif
messageHeadersGetList ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetOneMethodInfo ,
#endif
messageHeadersGetOne ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersGetRangesMethodInfo ,
#endif
messageHeadersGetRanges ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersHeaderContainsMethodInfo ,
#endif
messageHeadersHeaderContains ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersHeaderEqualsMethodInfo ,
#endif
messageHeadersHeaderEquals ,
messageHeadersNew ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersRefMethodInfo ,
#endif
messageHeadersRef ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersRemoveMethodInfo ,
#endif
messageHeadersRemove ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersReplaceMethodInfo ,
#endif
messageHeadersReplace ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersSetContentDispositionMethodInfo,
#endif
messageHeadersSetContentDisposition ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersSetContentLengthMethodInfo,
#endif
messageHeadersSetContentLength ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersSetContentRangeMethodInfo ,
#endif
messageHeadersSetContentRange ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersSetContentTypeMethodInfo ,
#endif
messageHeadersSetContentType ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersSetEncodingMethodInfo ,
#endif
messageHeadersSetEncoding ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersSetExpectationsMethodInfo ,
#endif
messageHeadersSetExpectations ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersSetRangeMethodInfo ,
#endif
messageHeadersSetRange ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersSetRangesMethodInfo ,
#endif
messageHeadersSetRanges ,
#if defined(ENABLE_OVERLOADING)
MessageHeadersUnrefMethodInfo ,
#endif
messageHeadersUnref ,
) 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.GHashTable as B.GHT
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.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.Soup.Callbacks as Soup.Callbacks
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Flags as Soup.Flags
import {-# SOURCE #-} qualified GI.Soup.Structs.Range as Soup.Range
newtype = (SP.ManagedPtr MessageHeaders)
deriving (MessageHeaders -> MessageHeaders -> Bool
(MessageHeaders -> MessageHeaders -> Bool)
-> (MessageHeaders -> MessageHeaders -> Bool) -> Eq MessageHeaders
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MessageHeaders -> MessageHeaders -> Bool
== :: MessageHeaders -> MessageHeaders -> Bool
$c/= :: MessageHeaders -> MessageHeaders -> Bool
/= :: MessageHeaders -> MessageHeaders -> Bool
Eq)
instance SP.ManagedPtrNewtype MessageHeaders where
toManagedPtr :: MessageHeaders -> ManagedPtr MessageHeaders
toManagedPtr (MessageHeaders ManagedPtr MessageHeaders
p) = ManagedPtr MessageHeaders
p
foreign import ccall "soup_message_headers_get_type" ::
IO GType
type instance O.ParentTypes MessageHeaders = '[]
instance O.HasParentTypes MessageHeaders
instance B.Types.TypedObject MessageHeaders where
glibType :: IO GType
glibType = IO GType
c_soup_message_headers_get_type
instance B.Types.GBoxed MessageHeaders
instance B.GValue.IsGValue (Maybe MessageHeaders) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_message_headers_get_type
gvalueSet_ :: Ptr GValue -> Maybe MessageHeaders -> IO ()
gvalueSet_ Ptr GValue
gv Maybe MessageHeaders
P.Nothing = Ptr GValue -> Ptr MessageHeaders -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr MessageHeaders
forall a. Ptr a
FP.nullPtr :: FP.Ptr MessageHeaders)
gvalueSet_ Ptr GValue
gv (P.Just MessageHeaders
obj) = MessageHeaders -> (Ptr MessageHeaders -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr MessageHeaders
obj (Ptr GValue -> Ptr MessageHeaders -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe MessageHeaders)
gvalueGet_ Ptr GValue
gv = do
Ptr MessageHeaders
ptr <- Ptr GValue -> IO (Ptr MessageHeaders)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr MessageHeaders)
if Ptr MessageHeaders
ptr Ptr MessageHeaders -> Ptr MessageHeaders -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr MessageHeaders
forall a. Ptr a
FP.nullPtr
then MessageHeaders -> Maybe MessageHeaders
forall a. a -> Maybe a
P.Just (MessageHeaders -> Maybe MessageHeaders)
-> IO MessageHeaders -> IO (Maybe MessageHeaders)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr MessageHeaders -> MessageHeaders
MessageHeaders Ptr MessageHeaders
ptr
else Maybe MessageHeaders -> IO (Maybe MessageHeaders)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MessageHeaders
forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList MessageHeaders
type instance O.AttributeList MessageHeaders = MessageHeadersAttributeList
type MessageHeadersAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "soup_message_headers_new" ::
CUInt ->
IO (Ptr MessageHeaders)
messageHeadersNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Soup.Enums.MessageHeadersType
-> m MessageHeaders
MessageHeadersType
type_ = IO MessageHeaders -> m MessageHeaders
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeaders -> m MessageHeaders)
-> IO MessageHeaders -> m MessageHeaders
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (MessageHeadersType -> Int) -> MessageHeadersType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MessageHeadersType -> Int
forall a. Enum a => a -> Int
fromEnum) MessageHeadersType
type_
Ptr MessageHeaders
result <- CUInt -> IO (Ptr MessageHeaders)
soup_message_headers_new CUInt
type_'
Text -> Ptr MessageHeaders -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageHeadersNew" Ptr MessageHeaders
result
MessageHeaders
result' <- ((ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MessageHeaders -> MessageHeaders
MessageHeaders) Ptr MessageHeaders
result
MessageHeaders -> IO MessageHeaders
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeaders
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "soup_message_headers_append" ::
Ptr MessageHeaders ->
CString ->
CString ->
IO ()
messageHeadersAppend ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> T.Text
-> m ()
MessageHeaders
hdrs Text
name Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
name' <- Text -> IO CString
textToCString Text
name
CString
value' <- Text -> IO CString
textToCString Text
value
Ptr MessageHeaders -> CString -> CString -> IO ()
soup_message_headers_append Ptr MessageHeaders
hdrs' CString
name' CString
value'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersAppendMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersAppendMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersAppend
instance O.OverloadedMethodInfo MessageHeadersAppendMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersAppend",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersAppend"
})
#endif
foreign import ccall "soup_message_headers_clean_connection_headers" ::
Ptr MessageHeaders ->
IO ()
messageHeadersCleanConnectionHeaders ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m ()
MessageHeaders
hdrs = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr MessageHeaders -> IO ()
soup_message_headers_clean_connection_headers Ptr MessageHeaders
hdrs'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersCleanConnectionHeadersMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MessageHeadersCleanConnectionHeadersMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersCleanConnectionHeaders
instance O.OverloadedMethodInfo MessageHeadersCleanConnectionHeadersMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersCleanConnectionHeaders",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersCleanConnectionHeaders"
})
#endif
foreign import ccall "soup_message_headers_clear" ::
Ptr MessageHeaders ->
IO ()
messageHeadersClear ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m ()
MessageHeaders
hdrs = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr MessageHeaders -> IO ()
soup_message_headers_clear Ptr MessageHeaders
hdrs'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersClearMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MessageHeadersClearMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersClear
instance O.OverloadedMethodInfo MessageHeadersClearMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersClear",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersClear"
})
#endif
foreign import ccall "soup_message_headers_foreach" ::
Ptr MessageHeaders ->
FunPtr Soup.Callbacks.C_MessageHeadersForeachFunc ->
Ptr () ->
IO ()
messageHeadersForeach ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> Soup.Callbacks.MessageHeadersForeachFunc
-> m ()
MessageHeaders
hdrs MessageHeadersForeachFunc
func = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
FunPtr C_MessageHeadersForeachFunc
func' <- C_MessageHeadersForeachFunc
-> IO (FunPtr C_MessageHeadersForeachFunc)
Soup.Callbacks.mk_MessageHeadersForeachFunc (Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc))
-> MessageHeadersForeachFunc_WithClosures
-> C_MessageHeadersForeachFunc
Soup.Callbacks.wrap_MessageHeadersForeachFunc Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc))
forall a. Maybe a
Nothing (MessageHeadersForeachFunc -> MessageHeadersForeachFunc_WithClosures
Soup.Callbacks.drop_closures_MessageHeadersForeachFunc MessageHeadersForeachFunc
func))
let userData :: Ptr a
userData = Ptr a
forall a. Ptr a
nullPtr
Ptr MessageHeaders
-> FunPtr C_MessageHeadersForeachFunc -> Ptr () -> IO ()
soup_message_headers_foreach Ptr MessageHeaders
hdrs' FunPtr C_MessageHeadersForeachFunc
func' Ptr ()
forall a. Ptr a
userData
Ptr Any -> IO ()
forall a. Ptr a -> IO ()
safeFreeFunPtr (Ptr Any -> IO ()) -> Ptr Any -> IO ()
forall a b. (a -> b) -> a -> b
$ FunPtr C_MessageHeadersForeachFunc -> Ptr Any
forall a b. FunPtr a -> Ptr b
castFunPtrToPtr FunPtr C_MessageHeadersForeachFunc
func'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersForeachMethodInfo
instance (signature ~ (Soup.Callbacks.MessageHeadersForeachFunc -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersForeachMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersForeach
instance O.OverloadedMethodInfo MessageHeadersForeachMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersForeach",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersForeach"
})
#endif
foreign import ccall "soup_message_headers_free_ranges" ::
Ptr MessageHeaders ->
Ptr Soup.Range.Range ->
IO ()
messageHeadersFreeRanges ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> Soup.Range.Range
-> m ()
MessageHeaders
hdrs Range
ranges = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr Range
ranges' <- Range -> IO (Ptr Range)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Range
ranges
Ptr MessageHeaders -> Ptr Range -> IO ()
soup_message_headers_free_ranges Ptr MessageHeaders
hdrs' Ptr Range
ranges'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
Range -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Range
ranges
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersFreeRangesMethodInfo
instance (signature ~ (Soup.Range.Range -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersFreeRangesMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersFreeRanges
instance O.OverloadedMethodInfo MessageHeadersFreeRangesMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersFreeRanges",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersFreeRanges"
})
#endif
foreign import ccall "soup_message_headers_get_content_disposition" ::
Ptr MessageHeaders ->
Ptr CString ->
Ptr (Ptr (GHashTable CString CString)) ->
IO CInt
messageHeadersGetContentDisposition ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m ((Bool, T.Text, Map.Map T.Text T.Text))
MessageHeaders
hdrs = IO (Bool, Text, Map Text Text) -> m (Bool, Text, Map Text Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text, Map Text Text) -> m (Bool, Text, Map Text Text))
-> IO (Bool, Text, Map Text Text) -> m (Bool, Text, Map Text Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr CString
disposition <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (Ptr (GHashTable CString CString))
params <- IO (Ptr (Ptr (GHashTable CString CString)))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GHashTable CString CString)))
CInt
result <- Ptr MessageHeaders
-> Ptr CString -> Ptr (Ptr (GHashTable CString CString)) -> IO CInt
soup_message_headers_get_content_disposition Ptr MessageHeaders
hdrs' Ptr CString
disposition Ptr (Ptr (GHashTable CString CString))
params
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
disposition' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
disposition
Text
disposition'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
disposition'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
disposition'
Ptr (GHashTable CString CString)
params' <- Ptr (Ptr (GHashTable CString CString))
-> IO (Ptr (GHashTable CString CString))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GHashTable CString CString))
params
[(PtrWrapped CString, PtrWrapped CString)]
params'' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
params'
let params''' :: [(CString, PtrWrapped CString)]
params''' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
B.GHT.cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
params''
[(Text, PtrWrapped CString)]
params'''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
params'''
let params''''' :: [(Text, CString)]
params''''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
B.GHT.cstringUnpackPtr [(Text, PtrWrapped CString)]
params''''
[(Text, Text)]
params'''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
params'''''
let params''''''' :: Map Text Text
params''''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
params''''''
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
params'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
disposition
Ptr (Ptr (GHashTable CString CString)) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GHashTable CString CString))
params
(Bool, Text, Map Text Text) -> IO (Bool, Text, Map Text Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
disposition'', Map Text Text
params''''''')
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetContentDispositionMethodInfo
instance (signature ~ (m ((Bool, T.Text, Map.Map T.Text T.Text))), MonadIO m) => O.OverloadedMethod MessageHeadersGetContentDispositionMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetContentDisposition
instance O.OverloadedMethodInfo MessageHeadersGetContentDispositionMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetContentDisposition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetContentDisposition"
})
#endif
foreign import ccall "soup_message_headers_get_content_length" ::
Ptr MessageHeaders ->
IO Int64
messageHeadersGetContentLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m Int64
MessageHeaders
hdrs = IO Int64 -> m Int64
forall a. IO a -> m a
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
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Int64
result <- Ptr MessageHeaders -> IO Int64
soup_message_headers_get_content_length Ptr MessageHeaders
hdrs'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
Int64 -> IO Int64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetContentLengthMethodInfo
instance (signature ~ (m Int64), MonadIO m) => O.OverloadedMethod MessageHeadersGetContentLengthMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetContentLength
instance O.OverloadedMethodInfo MessageHeadersGetContentLengthMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetContentLength",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetContentLength"
})
#endif
foreign import ccall "soup_message_headers_get_content_range" ::
Ptr MessageHeaders ->
Ptr Int64 ->
Ptr Int64 ->
Ptr Int64 ->
IO CInt
messageHeadersGetContentRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m ((Bool, Int64, Int64, Int64))
MessageHeaders
hdrs = IO (Bool, Int64, Int64, Int64) -> m (Bool, Int64, Int64, Int64)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Int64, Int64, Int64) -> m (Bool, Int64, Int64, Int64))
-> IO (Bool, Int64, Int64, Int64) -> m (Bool, Int64, Int64, Int64)
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr Int64
start <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Int64
end <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
Ptr Int64
totalLength <- IO (Ptr Int64)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int64)
CInt
result <- Ptr MessageHeaders
-> Ptr Int64 -> Ptr Int64 -> Ptr Int64 -> IO CInt
soup_message_headers_get_content_range Ptr MessageHeaders
hdrs' Ptr Int64
start Ptr Int64
end Ptr Int64
totalLength
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Int64
start' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
start
Int64
end' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
end
Int64
totalLength' <- Ptr Int64 -> IO Int64
forall a. Storable a => Ptr a -> IO a
peek Ptr Int64
totalLength
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
start
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
end
Ptr Int64 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int64
totalLength
(Bool, Int64, Int64, Int64) -> IO (Bool, Int64, Int64, Int64)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Int64
start', Int64
end', Int64
totalLength')
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetContentRangeMethodInfo
instance (signature ~ (m ((Bool, Int64, Int64, Int64))), MonadIO m) => O.OverloadedMethod MessageHeadersGetContentRangeMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetContentRange
instance O.OverloadedMethodInfo MessageHeadersGetContentRangeMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetContentRange",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetContentRange"
})
#endif
foreign import ccall "soup_message_headers_get_content_type" ::
Ptr MessageHeaders ->
Ptr (Ptr (GHashTable CString CString)) ->
IO CString
messageHeadersGetContentType ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m ((Maybe T.Text, Map.Map T.Text T.Text))
MessageHeaders
hdrs = IO (Maybe Text, Map Text Text) -> m (Maybe Text, Map Text Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, Map Text Text) -> m (Maybe Text, Map Text Text))
-> IO (Maybe Text, Map Text Text) -> m (Maybe Text, Map Text Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr (Ptr (GHashTable CString CString))
params <- IO (Ptr (Ptr (GHashTable CString CString)))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GHashTable CString CString)))
CString
result <- Ptr MessageHeaders
-> Ptr (Ptr (GHashTable CString CString)) -> IO CString
soup_message_headers_get_content_type Ptr MessageHeaders
hdrs' Ptr (Ptr (GHashTable CString CString))
params
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
Ptr (GHashTable CString CString)
params' <- Ptr (Ptr (GHashTable CString CString))
-> IO (Ptr (GHashTable CString CString))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GHashTable CString CString))
params
[(PtrWrapped CString, PtrWrapped CString)]
params'' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
params'
let params''' :: [(CString, PtrWrapped CString)]
params''' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
B.GHT.cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
params''
[(Text, PtrWrapped CString)]
params'''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
params'''
let params''''' :: [(Text, CString)]
params''''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
B.GHT.cstringUnpackPtr [(Text, PtrWrapped CString)]
params''''
[(Text, Text)]
params'''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
params'''''
let params''''''' :: Map Text Text
params''''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
params''''''
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
params'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
Ptr (Ptr (GHashTable CString CString)) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GHashTable CString CString))
params
(Maybe Text, Map Text Text) -> IO (Maybe Text, Map Text Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Text
maybeResult, Map Text Text
params''''''')
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetContentTypeMethodInfo
instance (signature ~ (m ((Maybe T.Text, Map.Map T.Text T.Text))), MonadIO m) => O.OverloadedMethod MessageHeadersGetContentTypeMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetContentType
instance O.OverloadedMethodInfo MessageHeadersGetContentTypeMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetContentType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetContentType"
})
#endif
foreign import ccall "soup_message_headers_get_encoding" ::
Ptr MessageHeaders ->
IO CUInt
messageHeadersGetEncoding ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m Soup.Enums.Encoding
MessageHeaders
hdrs = IO Encoding -> m Encoding
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Encoding -> m Encoding) -> IO Encoding -> m Encoding
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CUInt
result <- Ptr MessageHeaders -> IO CUInt
soup_message_headers_get_encoding Ptr MessageHeaders
hdrs'
let result' :: Encoding
result' = (Int -> Encoding
forall a. Enum a => Int -> a
toEnum (Int -> Encoding) -> (CUInt -> Int) -> CUInt -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
Encoding -> IO Encoding
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Encoding
result'
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetEncodingMethodInfo
instance (signature ~ (m Soup.Enums.Encoding), MonadIO m) => O.OverloadedMethod MessageHeadersGetEncodingMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetEncoding
instance O.OverloadedMethodInfo MessageHeadersGetEncodingMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetEncoding",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetEncoding"
})
#endif
foreign import ccall "soup_message_headers_get_expectations" ::
Ptr MessageHeaders ->
IO CUInt
messageHeadersGetExpectations ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m [Soup.Flags.Expectation]
MessageHeaders
hdrs = IO [Expectation] -> m [Expectation]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Expectation] -> m [Expectation])
-> IO [Expectation] -> m [Expectation]
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CUInt
result <- Ptr MessageHeaders -> IO CUInt
soup_message_headers_get_expectations Ptr MessageHeaders
hdrs'
let result' :: [Expectation]
result' = CUInt -> [Expectation]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
[Expectation] -> IO [Expectation]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Expectation]
result'
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetExpectationsMethodInfo
instance (signature ~ (m [Soup.Flags.Expectation]), MonadIO m) => O.OverloadedMethod MessageHeadersGetExpectationsMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetExpectations
instance O.OverloadedMethodInfo MessageHeadersGetExpectationsMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetExpectations",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetExpectations"
})
#endif
foreign import ccall "soup_message_headers_get_headers_type" ::
Ptr MessageHeaders ->
IO CUInt
messageHeadersGetHeadersType ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m Soup.Enums.MessageHeadersType
MessageHeaders
hdrs = IO MessageHeadersType -> m MessageHeadersType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeadersType -> m MessageHeadersType)
-> IO MessageHeadersType -> m MessageHeadersType
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CUInt
result <- Ptr MessageHeaders -> IO CUInt
soup_message_headers_get_headers_type Ptr MessageHeaders
hdrs'
let result' :: MessageHeadersType
result' = (Int -> MessageHeadersType
forall a. Enum a => Int -> a
toEnum (Int -> MessageHeadersType)
-> (CUInt -> Int) -> CUInt -> MessageHeadersType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
MessageHeadersType -> IO MessageHeadersType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeadersType
result'
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetHeadersTypeMethodInfo
instance (signature ~ (m Soup.Enums.MessageHeadersType), MonadIO m) => O.OverloadedMethod MessageHeadersGetHeadersTypeMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetHeadersType
instance O.OverloadedMethodInfo MessageHeadersGetHeadersTypeMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetHeadersType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetHeadersType"
})
#endif
foreign import ccall "soup_message_headers_get_list" ::
Ptr MessageHeaders ->
CString ->
IO CString
messageHeadersGetList ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> m (Maybe T.Text)
MessageHeaders
hdrs Text
name = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
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
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
name' <- Text -> IO CString
textToCString Text
name
CString
result <- Ptr MessageHeaders -> CString -> IO CString
soup_message_headers_get_list Ptr MessageHeaders
hdrs' CString
name'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetListMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod MessageHeadersGetListMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetList
instance O.OverloadedMethodInfo MessageHeadersGetListMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetList",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetList"
})
#endif
foreign import ccall "soup_message_headers_get_one" ::
Ptr MessageHeaders ->
CString ->
IO CString
messageHeadersGetOne ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> m (Maybe T.Text)
MessageHeaders
hdrs Text
name = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
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
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
name' <- Text -> IO CString
textToCString Text
name
CString
result <- Ptr MessageHeaders -> CString -> IO CString
soup_message_headers_get_one Ptr MessageHeaders
hdrs' CString
name'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetOneMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod MessageHeadersGetOneMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetOne
instance O.OverloadedMethodInfo MessageHeadersGetOneMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetOne",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetOne"
})
#endif
foreign import ccall "soup_message_headers_get_ranges" ::
Ptr MessageHeaders ->
Int64 ->
Ptr (Ptr Soup.Range.Range) ->
Ptr Int32 ->
IO CInt
messageHeadersGetRanges ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> Int64
-> m ((Bool, [Soup.Range.Range]))
MessageHeaders
hdrs Int64
totalLength = IO (Bool, [Range]) -> m (Bool, [Range])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, [Range]) -> m (Bool, [Range]))
-> IO (Bool, [Range]) -> m (Bool, [Range])
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr (Ptr Range)
ranges <- IO (Ptr (Ptr Range))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Soup.Range.Range))
Ptr Int32
length_ <- IO (Ptr Int32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Int32)
CInt
result <- Ptr MessageHeaders
-> Int64 -> Ptr (Ptr Range) -> Ptr Int32 -> IO CInt
soup_message_headers_get_ranges Ptr MessageHeaders
hdrs' Int64
totalLength Ptr (Ptr Range)
ranges Ptr Int32
length_
Int32
length_' <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek Ptr Int32
length_
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Ptr Range
ranges' <- Ptr (Ptr Range) -> IO (Ptr Range)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr Range)
ranges
[Ptr Range]
ranges'' <- (Int -> Int32 -> Ptr Range -> IO [Ptr Range]
forall a b. Integral a => Int -> a -> Ptr b -> IO [Ptr b]
unpackBlockArrayWithLength Int
16 Int32
length_') Ptr Range
ranges'
[Range]
ranges''' <- (Ptr Range -> IO Range) -> [Ptr Range] -> IO [Range]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((ManagedPtr Range -> Range) -> Ptr Range -> IO Range
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr Range -> Range
Soup.Range.Range) [Ptr Range]
ranges''
Ptr Range -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Range
ranges'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
Ptr (Ptr Range) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr Range)
ranges
Ptr Int32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Int32
length_
(Bool, [Range]) -> IO (Bool, [Range])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', [Range]
ranges''')
#if defined(ENABLE_OVERLOADING)
data MessageHeadersGetRangesMethodInfo
instance (signature ~ (Int64 -> m ((Bool, [Soup.Range.Range]))), MonadIO m) => O.OverloadedMethod MessageHeadersGetRangesMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersGetRanges
instance O.OverloadedMethodInfo MessageHeadersGetRangesMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGetRanges",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetRanges"
})
#endif
foreign import ccall "soup_message_headers_header_contains" ::
Ptr MessageHeaders ->
CString ->
CString ->
IO CInt
messageHeadersHeaderContains ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> T.Text
-> m Bool
MessageHeaders
hdrs Text
name Text
token = IO Bool -> m Bool
forall a. IO a -> m a
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 MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
name' <- Text -> IO CString
textToCString Text
name
CString
token' <- Text -> IO CString
textToCString Text
token
CInt
result <- Ptr MessageHeaders -> CString -> CString -> IO CInt
soup_message_headers_header_contains Ptr MessageHeaders
hdrs' CString
name' CString
token'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
token'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data MessageHeadersHeaderContainsMethodInfo
instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => O.OverloadedMethod MessageHeadersHeaderContainsMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersHeaderContains
instance O.OverloadedMethodInfo MessageHeadersHeaderContainsMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersHeaderContains",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersHeaderContains"
})
#endif
foreign import ccall "soup_message_headers_header_equals" ::
Ptr MessageHeaders ->
CString ->
CString ->
IO CInt
messageHeadersHeaderEquals ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> T.Text
-> m Bool
MessageHeaders
hdrs Text
name Text
value = IO Bool -> m Bool
forall a. IO a -> m a
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 MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
name' <- Text -> IO CString
textToCString Text
name
CString
value' <- Text -> IO CString
textToCString Text
value
CInt
result <- Ptr MessageHeaders -> CString -> CString -> IO CInt
soup_message_headers_header_equals Ptr MessageHeaders
hdrs' CString
name' CString
value'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data MessageHeadersHeaderEqualsMethodInfo
instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => O.OverloadedMethod MessageHeadersHeaderEqualsMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersHeaderEquals
instance O.OverloadedMethodInfo MessageHeadersHeaderEqualsMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersHeaderEquals",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersHeaderEquals"
})
#endif
foreign import ccall "soup_message_headers_ref" ::
Ptr MessageHeaders ->
IO (Ptr MessageHeaders)
messageHeadersRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m MessageHeaders
MessageHeaders
hdrs = IO MessageHeaders -> m MessageHeaders
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeaders -> m MessageHeaders)
-> IO MessageHeaders -> m MessageHeaders
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr MessageHeaders
result <- Ptr MessageHeaders -> IO (Ptr MessageHeaders)
soup_message_headers_ref Ptr MessageHeaders
hdrs'
Text -> Ptr MessageHeaders -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"messageHeadersRef" Ptr MessageHeaders
result
MessageHeaders
result' <- ((ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr MessageHeaders -> MessageHeaders
MessageHeaders) Ptr MessageHeaders
result
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
MessageHeaders -> IO MessageHeaders
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeaders
result'
#if defined(ENABLE_OVERLOADING)
data MessageHeadersRefMethodInfo
instance (signature ~ (m MessageHeaders), MonadIO m) => O.OverloadedMethod MessageHeadersRefMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersRef
instance O.OverloadedMethodInfo MessageHeadersRefMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersRef"
})
#endif
foreign import ccall "soup_message_headers_remove" ::
Ptr MessageHeaders ->
CString ->
IO ()
messageHeadersRemove ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> m ()
MessageHeaders
hdrs Text
name = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr MessageHeaders -> CString -> IO ()
soup_message_headers_remove Ptr MessageHeaders
hdrs' CString
name'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersRemoveMethodInfo
instance (signature ~ (T.Text -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersRemoveMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersRemove
instance O.OverloadedMethodInfo MessageHeadersRemoveMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersRemove",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersRemove"
})
#endif
foreign import ccall "soup_message_headers_replace" ::
Ptr MessageHeaders ->
CString ->
CString ->
IO ()
messageHeadersReplace ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> T.Text
-> m ()
MessageHeaders
hdrs Text
name Text
value = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
name' <- Text -> IO CString
textToCString Text
name
CString
value' <- Text -> IO CString
textToCString Text
value
Ptr MessageHeaders -> CString -> CString -> IO ()
soup_message_headers_replace Ptr MessageHeaders
hdrs' CString
name' CString
value'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersReplaceMethodInfo
instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersReplaceMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersReplace
instance O.OverloadedMethodInfo MessageHeadersReplaceMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersReplace",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersReplace"
})
#endif
foreign import ccall "soup_message_headers_set_content_disposition" ::
Ptr MessageHeaders ->
CString ->
Ptr (GHashTable CString CString) ->
IO ()
messageHeadersSetContentDisposition ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> Maybe (Map.Map T.Text T.Text)
-> m ()
MessageHeaders
hdrs Text
disposition Maybe (Map Text Text)
params = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
disposition' <- Text -> IO CString
textToCString Text
disposition
Ptr (GHashTable CString CString)
maybeParams <- case Maybe (Map Text Text)
params of
Maybe (Map Text Text)
Nothing -> Ptr (GHashTable CString CString)
-> IO (Ptr (GHashTable CString CString))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GHashTable CString CString)
forall a. Ptr a
nullPtr
Just Map Text Text
jParams -> do
let jParams' :: [(Text, Text)]
jParams' = Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
jParams
[(CString, Text)]
jParams'' <- (Text -> IO CString) -> [(Text, Text)] -> IO [(CString, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO CString
textToCString [(Text, Text)]
jParams'
[(CString, CString)]
jParams''' <- (Text -> IO CString)
-> [(CString, Text)] -> IO [(CString, CString)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO CString
textToCString [(CString, Text)]
jParams''
let jParams'''' :: [(PtrWrapped CString, CString)]
jParams'''' = (CString -> PtrWrapped CString)
-> [(CString, CString)] -> [(PtrWrapped CString, CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst CString -> PtrWrapped CString
B.GHT.cstringPackPtr [(CString, CString)]
jParams'''
let jParams''''' :: [(PtrWrapped CString, PtrWrapped CString)]
jParams''''' = (CString -> PtrWrapped CString)
-> [(PtrWrapped CString, CString)]
-> [(PtrWrapped CString, PtrWrapped CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond CString -> PtrWrapped CString
B.GHT.cstringPackPtr [(PtrWrapped CString, CString)]
jParams''''
Ptr (GHashTable CString CString)
jParams'''''' <- GHashFunc CString
-> GEqualFunc CString
-> Maybe (GDestroyNotify CString)
-> Maybe (GDestroyNotify CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> IO (Ptr (GHashTable CString CString))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc CString
gStrHash GEqualFunc CString
gStrEqual (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped CString, PtrWrapped CString)]
jParams'''''
Ptr (GHashTable CString CString)
-> IO (Ptr (GHashTable CString CString))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GHashTable CString CString)
jParams''''''
Ptr MessageHeaders
-> CString -> Ptr (GHashTable CString CString) -> IO ()
soup_message_headers_set_content_disposition Ptr MessageHeaders
hdrs' CString
disposition' Ptr (GHashTable CString CString)
maybeParams
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
disposition'
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
maybeParams
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersSetContentDispositionMethodInfo
instance (signature ~ (T.Text -> Maybe (Map.Map T.Text T.Text) -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersSetContentDispositionMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersSetContentDisposition
instance O.OverloadedMethodInfo MessageHeadersSetContentDispositionMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersSetContentDisposition",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetContentDisposition"
})
#endif
foreign import ccall "soup_message_headers_set_content_length" ::
Ptr MessageHeaders ->
Int64 ->
IO ()
messageHeadersSetContentLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> Int64
-> m ()
MessageHeaders
hdrs Int64
contentLength = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr MessageHeaders -> Int64 -> IO ()
soup_message_headers_set_content_length Ptr MessageHeaders
hdrs' Int64
contentLength
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersSetContentLengthMethodInfo
instance (signature ~ (Int64 -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersSetContentLengthMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersSetContentLength
instance O.OverloadedMethodInfo MessageHeadersSetContentLengthMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersSetContentLength",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetContentLength"
})
#endif
foreign import ccall "soup_message_headers_set_content_range" ::
Ptr MessageHeaders ->
Int64 ->
Int64 ->
Int64 ->
IO ()
messageHeadersSetContentRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> Int64
-> Int64
-> Int64
-> m ()
MessageHeaders
hdrs Int64
start Int64
end Int64
totalLength = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr MessageHeaders -> Int64 -> Int64 -> Int64 -> IO ()
soup_message_headers_set_content_range Ptr MessageHeaders
hdrs' Int64
start Int64
end Int64
totalLength
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersSetContentRangeMethodInfo
instance (signature ~ (Int64 -> Int64 -> Int64 -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersSetContentRangeMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersSetContentRange
instance O.OverloadedMethodInfo MessageHeadersSetContentRangeMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersSetContentRange",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetContentRange"
})
#endif
foreign import ccall "soup_message_headers_set_content_type" ::
Ptr MessageHeaders ->
CString ->
Ptr (GHashTable CString CString) ->
IO ()
messageHeadersSetContentType ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> T.Text
-> Maybe (Map.Map T.Text T.Text)
-> m ()
MessageHeaders
hdrs Text
contentType Maybe (Map Text Text)
params = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
CString
contentType' <- Text -> IO CString
textToCString Text
contentType
Ptr (GHashTable CString CString)
maybeParams <- case Maybe (Map Text Text)
params of
Maybe (Map Text Text)
Nothing -> Ptr (GHashTable CString CString)
-> IO (Ptr (GHashTable CString CString))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GHashTable CString CString)
forall a. Ptr a
nullPtr
Just Map Text Text
jParams -> do
let jParams' :: [(Text, Text)]
jParams' = Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
jParams
[(CString, Text)]
jParams'' <- (Text -> IO CString) -> [(Text, Text)] -> IO [(CString, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO CString
textToCString [(Text, Text)]
jParams'
[(CString, CString)]
jParams''' <- (Text -> IO CString)
-> [(CString, Text)] -> IO [(CString, CString)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO CString
textToCString [(CString, Text)]
jParams''
let jParams'''' :: [(PtrWrapped CString, CString)]
jParams'''' = (CString -> PtrWrapped CString)
-> [(CString, CString)] -> [(PtrWrapped CString, CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst CString -> PtrWrapped CString
B.GHT.cstringPackPtr [(CString, CString)]
jParams'''
let jParams''''' :: [(PtrWrapped CString, PtrWrapped CString)]
jParams''''' = (CString -> PtrWrapped CString)
-> [(PtrWrapped CString, CString)]
-> [(PtrWrapped CString, PtrWrapped CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond CString -> PtrWrapped CString
B.GHT.cstringPackPtr [(PtrWrapped CString, CString)]
jParams''''
Ptr (GHashTable CString CString)
jParams'''''' <- GHashFunc CString
-> GEqualFunc CString
-> Maybe (GDestroyNotify CString)
-> Maybe (GDestroyNotify CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> IO (Ptr (GHashTable CString CString))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc CString
gStrHash GEqualFunc CString
gStrEqual (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped CString, PtrWrapped CString)]
jParams'''''
Ptr (GHashTable CString CString)
-> IO (Ptr (GHashTable CString CString))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GHashTable CString CString)
jParams''''''
Ptr MessageHeaders
-> CString -> Ptr (GHashTable CString CString) -> IO ()
soup_message_headers_set_content_type Ptr MessageHeaders
hdrs' CString
contentType' Ptr (GHashTable CString CString)
maybeParams
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
contentType'
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
maybeParams
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersSetContentTypeMethodInfo
instance (signature ~ (T.Text -> Maybe (Map.Map T.Text T.Text) -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersSetContentTypeMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersSetContentType
instance O.OverloadedMethodInfo MessageHeadersSetContentTypeMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersSetContentType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetContentType"
})
#endif
foreign import ccall "soup_message_headers_set_encoding" ::
Ptr MessageHeaders ->
CUInt ->
IO ()
messageHeadersSetEncoding ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> Soup.Enums.Encoding
-> m ()
MessageHeaders
hdrs Encoding
encoding = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
let encoding' :: CUInt
encoding' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (Encoding -> Int) -> Encoding -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Encoding -> Int
forall a. Enum a => a -> Int
fromEnum) Encoding
encoding
Ptr MessageHeaders -> CUInt -> IO ()
soup_message_headers_set_encoding Ptr MessageHeaders
hdrs' CUInt
encoding'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersSetEncodingMethodInfo
instance (signature ~ (Soup.Enums.Encoding -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersSetEncodingMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersSetEncoding
instance O.OverloadedMethodInfo MessageHeadersSetEncodingMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersSetEncoding",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetEncoding"
})
#endif
foreign import ccall "soup_message_headers_set_expectations" ::
Ptr MessageHeaders ->
CUInt ->
IO ()
messageHeadersSetExpectations ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> [Soup.Flags.Expectation]
-> m ()
MessageHeaders
hdrs [Expectation]
expectations = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
let expectations' :: CUInt
expectations' = [Expectation] -> CUInt
forall b a. (Num b, IsGFlag a) => [a] -> b
gflagsToWord [Expectation]
expectations
Ptr MessageHeaders -> CUInt -> IO ()
soup_message_headers_set_expectations Ptr MessageHeaders
hdrs' CUInt
expectations'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersSetExpectationsMethodInfo
instance (signature ~ ([Soup.Flags.Expectation] -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersSetExpectationsMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersSetExpectations
instance O.OverloadedMethodInfo MessageHeadersSetExpectationsMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersSetExpectations",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetExpectations"
})
#endif
foreign import ccall "soup_message_headers_set_range" ::
Ptr MessageHeaders ->
Int64 ->
Int64 ->
IO ()
messageHeadersSetRange ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> Int64
-> Int64
-> m ()
MessageHeaders
hdrs Int64
start Int64
end = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr MessageHeaders -> Int64 -> Int64 -> IO ()
soup_message_headers_set_range Ptr MessageHeaders
hdrs' Int64
start Int64
end
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersSetRangeMethodInfo
instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersSetRangeMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersSetRange
instance O.OverloadedMethodInfo MessageHeadersSetRangeMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersSetRange",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetRange"
})
#endif
foreign import ccall "soup_message_headers_set_ranges" ::
Ptr MessageHeaders ->
Ptr Soup.Range.Range ->
Int32 ->
IO ()
messageHeadersSetRanges ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> Soup.Range.Range
-> Int32
-> m ()
MessageHeaders
hdrs Range
ranges Int32
length_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr Range
ranges' <- Range -> IO (Ptr Range)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Range
ranges
Ptr MessageHeaders -> Ptr Range -> Int32 -> IO ()
soup_message_headers_set_ranges Ptr MessageHeaders
hdrs' Ptr Range
ranges' Int32
length_
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
Range -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Range
ranges
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersSetRangesMethodInfo
instance (signature ~ (Soup.Range.Range -> Int32 -> m ()), MonadIO m) => O.OverloadedMethod MessageHeadersSetRangesMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersSetRanges
instance O.OverloadedMethodInfo MessageHeadersSetRangesMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersSetRanges",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetRanges"
})
#endif
foreign import ccall "soup_message_headers_unref" ::
Ptr MessageHeaders ->
IO ()
messageHeadersUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
MessageHeaders
-> m ()
MessageHeaders
hdrs = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr MessageHeaders
hdrs' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
hdrs
Ptr MessageHeaders -> IO ()
soup_message_headers_unref Ptr MessageHeaders
hdrs'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
hdrs
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data MessageHeadersUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MessageHeadersUnrefMethodInfo MessageHeaders signature where
overloadedMethod = messageHeadersUnref
instance O.OverloadedMethodInfo MessageHeadersUnrefMethodInfo MessageHeaders where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveMessageHeadersMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveMessageHeadersMethod "append" o = MessageHeadersAppendMethodInfo
ResolveMessageHeadersMethod "cleanConnectionHeaders" o = MessageHeadersCleanConnectionHeadersMethodInfo
ResolveMessageHeadersMethod "clear" o = MessageHeadersClearMethodInfo
ResolveMessageHeadersMethod "foreach" o = MessageHeadersForeachMethodInfo
ResolveMessageHeadersMethod "freeRanges" o = MessageHeadersFreeRangesMethodInfo
ResolveMessageHeadersMethod "headerContains" o = MessageHeadersHeaderContainsMethodInfo
ResolveMessageHeadersMethod "headerEquals" o = MessageHeadersHeaderEqualsMethodInfo
ResolveMessageHeadersMethod "ref" o = MessageHeadersRefMethodInfo
ResolveMessageHeadersMethod "remove" o = MessageHeadersRemoveMethodInfo
ResolveMessageHeadersMethod "replace" o = MessageHeadersReplaceMethodInfo
ResolveMessageHeadersMethod "unref" o = MessageHeadersUnrefMethodInfo
ResolveMessageHeadersMethod "getContentDisposition" o = MessageHeadersGetContentDispositionMethodInfo
ResolveMessageHeadersMethod "getContentLength" o = MessageHeadersGetContentLengthMethodInfo
ResolveMessageHeadersMethod "getContentRange" o = MessageHeadersGetContentRangeMethodInfo
ResolveMessageHeadersMethod "getContentType" o = MessageHeadersGetContentTypeMethodInfo
ResolveMessageHeadersMethod "getEncoding" o = MessageHeadersGetEncodingMethodInfo
ResolveMessageHeadersMethod "getExpectations" o = MessageHeadersGetExpectationsMethodInfo
ResolveMessageHeadersMethod "getHeadersType" o = MessageHeadersGetHeadersTypeMethodInfo
ResolveMessageHeadersMethod "getList" o = MessageHeadersGetListMethodInfo
ResolveMessageHeadersMethod "getOne" o = MessageHeadersGetOneMethodInfo
ResolveMessageHeadersMethod "getRanges" o = MessageHeadersGetRangesMethodInfo
ResolveMessageHeadersMethod "setContentDisposition" o = MessageHeadersSetContentDispositionMethodInfo
ResolveMessageHeadersMethod "setContentLength" o = MessageHeadersSetContentLengthMethodInfo
ResolveMessageHeadersMethod "setContentRange" o = MessageHeadersSetContentRangeMethodInfo
ResolveMessageHeadersMethod "setContentType" o = MessageHeadersSetContentTypeMethodInfo
ResolveMessageHeadersMethod "setEncoding" o = MessageHeadersSetEncodingMethodInfo
ResolveMessageHeadersMethod "setExpectations" o = MessageHeadersSetExpectationsMethodInfo
ResolveMessageHeadersMethod "setRange" o = MessageHeadersSetRangeMethodInfo
ResolveMessageHeadersMethod "setRanges" o = MessageHeadersSetRangesMethodInfo
ResolveMessageHeadersMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMessageHeadersMethod t MessageHeaders, O.OverloadedMethod info MessageHeaders p) => OL.IsLabel t (MessageHeaders -> 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 ~ ResolveMessageHeadersMethod t MessageHeaders, O.OverloadedMethod info MessageHeaders p, R.HasField t MessageHeaders p) => R.HasField t MessageHeaders p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveMessageHeadersMethod t MessageHeaders, O.OverloadedMethodInfo info MessageHeaders) => OL.IsLabel t (O.MethodProxy info MessageHeaders) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif