{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- The HTTP message headers associated with a request or response.

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

module GI.Soup.Structs.MessageHeaders
    ( 

-- * Exported types
    MessageHeaders(..)                      ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [append]("GI.Soup.Structs.MessageHeaders#g:method:append"), [cleanConnectionHeaders]("GI.Soup.Structs.MessageHeaders#g:method:cleanConnectionHeaders"), [clear]("GI.Soup.Structs.MessageHeaders#g:method:clear"), [foreach]("GI.Soup.Structs.MessageHeaders#g:method:foreach"), [free]("GI.Soup.Structs.MessageHeaders#g:method:free"), [freeRanges]("GI.Soup.Structs.MessageHeaders#g:method:freeRanges"), [get]("GI.Soup.Structs.MessageHeaders#g:method:get"), [headerContains]("GI.Soup.Structs.MessageHeaders#g:method:headerContains"), [headerEquals]("GI.Soup.Structs.MessageHeaders#g:method:headerEquals"), [remove]("GI.Soup.Structs.MessageHeaders#g:method:remove"), [replace]("GI.Soup.Structs.MessageHeaders#g:method:replace").
-- 
-- ==== Getters
-- [getContentDisposition]("GI.Soup.Structs.MessageHeaders#g:method:getContentDisposition"), [getContentLength]("GI.Soup.Structs.MessageHeaders#g:method:getContentLength"), [getContentRange]("GI.Soup.Structs.MessageHeaders#g:method:getContentRange"), [getContentType]("GI.Soup.Structs.MessageHeaders#g:method:getContentType"), [getEncoding]("GI.Soup.Structs.MessageHeaders#g:method:getEncoding"), [getExpectations]("GI.Soup.Structs.MessageHeaders#g:method:getExpectations"), [getHeadersType]("GI.Soup.Structs.MessageHeaders#g:method:getHeadersType"), [getList]("GI.Soup.Structs.MessageHeaders#g:method:getList"), [getOne]("GI.Soup.Structs.MessageHeaders#g:method:getOne"), [getRanges]("GI.Soup.Structs.MessageHeaders#g:method:getRanges").
-- 
-- ==== Setters
-- [setContentDisposition]("GI.Soup.Structs.MessageHeaders#g:method:setContentDisposition"), [setContentLength]("GI.Soup.Structs.MessageHeaders#g:method:setContentLength"), [setContentRange]("GI.Soup.Structs.MessageHeaders#g:method:setContentRange"), [setContentType]("GI.Soup.Structs.MessageHeaders#g:method:setContentType"), [setEncoding]("GI.Soup.Structs.MessageHeaders#g:method:setEncoding"), [setExpectations]("GI.Soup.Structs.MessageHeaders#g:method:setExpectations"), [setRange]("GI.Soup.Structs.MessageHeaders#g:method:setRange"), [setRanges]("GI.Soup.Structs.MessageHeaders#g:method:setRanges").

#if defined(ENABLE_OVERLOADING)
    ResolveMessageHeadersMethod             ,
#endif

-- ** append #method:append#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersAppendMethodInfo          ,
#endif
    messageHeadersAppend                    ,


-- ** cleanConnectionHeaders #method:cleanConnectionHeaders#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersCleanConnectionHeadersMethodInfo,
#endif
    messageHeadersCleanConnectionHeaders    ,


-- ** clear #method:clear#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersClearMethodInfo           ,
#endif
    messageHeadersClear                     ,


-- ** foreach #method:foreach#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersForeachMethodInfo         ,
#endif
    messageHeadersForeach                   ,


-- ** free #method:free#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersFreeMethodInfo            ,
#endif
    messageHeadersFree                      ,


-- ** freeRanges #method:freeRanges#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersFreeRangesMethodInfo      ,
#endif
    messageHeadersFreeRanges                ,


-- ** get #method:get#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetMethodInfo             ,
#endif
    messageHeadersGet                       ,


-- ** getContentDisposition #method:getContentDisposition#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetContentDispositionMethodInfo,
#endif
    messageHeadersGetContentDisposition     ,


-- ** getContentLength #method:getContentLength#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetContentLengthMethodInfo,
#endif
    messageHeadersGetContentLength          ,


-- ** getContentRange #method:getContentRange#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetContentRangeMethodInfo ,
#endif
    messageHeadersGetContentRange           ,


-- ** getContentType #method:getContentType#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetContentTypeMethodInfo  ,
#endif
    messageHeadersGetContentType            ,


-- ** getEncoding #method:getEncoding#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetEncodingMethodInfo     ,
#endif
    messageHeadersGetEncoding               ,


-- ** getExpectations #method:getExpectations#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetExpectationsMethodInfo ,
#endif
    messageHeadersGetExpectations           ,


-- ** getHeadersType #method:getHeadersType#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetHeadersTypeMethodInfo  ,
#endif
    messageHeadersGetHeadersType            ,


-- ** getList #method:getList#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetListMethodInfo         ,
#endif
    messageHeadersGetList                   ,


-- ** getOne #method:getOne#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetOneMethodInfo          ,
#endif
    messageHeadersGetOne                    ,


-- ** getRanges #method:getRanges#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersGetRangesMethodInfo       ,
#endif
    messageHeadersGetRanges                 ,


-- ** headerContains #method:headerContains#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersHeaderContainsMethodInfo  ,
#endif
    messageHeadersHeaderContains            ,


-- ** headerEquals #method:headerEquals#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersHeaderEqualsMethodInfo    ,
#endif
    messageHeadersHeaderEquals              ,


-- ** new #method:new#

    messageHeadersNew                       ,


-- ** remove #method:remove#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersRemoveMethodInfo          ,
#endif
    messageHeadersRemove                    ,


-- ** replace #method:replace#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersReplaceMethodInfo         ,
#endif
    messageHeadersReplace                   ,


-- ** setContentDisposition #method:setContentDisposition#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersSetContentDispositionMethodInfo,
#endif
    messageHeadersSetContentDisposition     ,


-- ** setContentLength #method:setContentLength#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersSetContentLengthMethodInfo,
#endif
    messageHeadersSetContentLength          ,


-- ** setContentRange #method:setContentRange#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersSetContentRangeMethodInfo ,
#endif
    messageHeadersSetContentRange           ,


-- ** setContentType #method:setContentType#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersSetContentTypeMethodInfo  ,
#endif
    messageHeadersSetContentType            ,


-- ** setEncoding #method:setEncoding#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersSetEncodingMethodInfo     ,
#endif
    messageHeadersSetEncoding               ,


-- ** setExpectations #method:setExpectations#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersSetExpectationsMethodInfo ,
#endif
    messageHeadersSetExpectations           ,


-- ** setRange #method:setRange#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersSetRangeMethodInfo        ,
#endif
    messageHeadersSetRange                  ,


-- ** setRanges #method:setRanges#

#if defined(ENABLE_OVERLOADING)
    MessageHeadersSetRangesMethodInfo       ,
#endif
    messageHeadersSetRanges                 ,




    ) 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.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

-- | Memory-managed wrapper type.
newtype MessageHeaders = MessageHeaders (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" c_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

-- | Convert 'MessageHeaders' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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, *)])
#endif

-- method MessageHeaders::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "type"
--           , argType =
--               TInterface
--                 Name { namespace = "Soup" , name = "MessageHeadersType" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the type of headers"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "MessageHeaders" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_new" soup_message_headers_new :: 
    CUInt ->                                -- type : TInterface (Name {namespace = "Soup", name = "MessageHeadersType"})
    IO (Ptr MessageHeaders)

-- | Creates a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'. (t'GI.Soup.Objects.Message.Message' does this
-- automatically for its own headers. You would only need to use this
-- method if you are manually parsing or generating message headers.)
messageHeadersNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Soup.Enums.MessageHeadersType
    -- ^ /@type@/: the type of headers
    -> m MessageHeaders
    -- ^ __Returns:__ a new t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
messageHeadersNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeadersType -> m MessageHeaders
messageHeadersNew 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

-- method MessageHeaders::append
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the header name to add"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value of @name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_append" soup_message_headers_append :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO ()

-- | Appends a new header with name /@name@/ and value /@value@/ to /@hdrs@/. (If
-- there is an existing header with name /@name@/, then this creates a
-- second one, which is only allowed for list-valued headers; see also
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersReplace'.)
-- 
-- The caller is expected to make sure that /@name@/ and /@value@/ are
-- syntactically correct.
messageHeadersAppend ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@name@/: the header name to add
    -> T.Text
    -- ^ /@value@/: the new value of /@name@/
    -> m ()
messageHeadersAppend :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> Text -> m ()
messageHeadersAppend 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersAppend"
        })


#endif

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

foreign import ccall "soup_message_headers_clean_connection_headers" soup_message_headers_clean_connection_headers :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO ()

-- | Removes all the headers listed in the Connection header.
-- 
-- /Since: 2.36/
messageHeadersCleanConnectionHeaders ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m ()
messageHeadersCleanConnectionHeaders :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m ()
messageHeadersCleanConnectionHeaders 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersCleanConnectionHeaders"
        })


#endif

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

foreign import ccall "soup_message_headers_clear" soup_message_headers_clear :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO ()

-- | Clears /@hdrs@/.
messageHeadersClear ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m ()
messageHeadersClear :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m ()
messageHeadersClear 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersClear"
        })


#endif

-- method MessageHeaders::foreach
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "func"
--           , argType =
--               TInterface
--                 Name { namespace = "Soup" , name = "MessageHeadersForeachFunc" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "callback function to run for each header"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeCall
--           , argClosure = 2
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "user_data"
--           , argType = TBasicType TPtr
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "data to pass to @func"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_foreach" soup_message_headers_foreach :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    FunPtr Soup.Callbacks.C_MessageHeadersForeachFunc -> -- func : TInterface (Name {namespace = "Soup", name = "MessageHeadersForeachFunc"})
    Ptr () ->                               -- user_data : TBasicType TPtr
    IO ()

-- | Calls /@func@/ once for each header value in /@hdrs@/.
-- 
-- Beware that unlike 'GI.Soup.Structs.MessageHeaders.messageHeadersGet', this processes the
-- headers in exactly the way they were added, rather than
-- concatenating multiple same-named headers into a single value.
-- (This is intentional; it ensures that if you call
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersAppend' multiple times with the same name,
-- then the I\/O code will output multiple copies of the header when
-- sending the message to the remote implementation, which may be
-- required for interoperability in some cases.)
-- 
-- You may not modify the headers from /@func@/.
messageHeadersForeach ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> Soup.Callbacks.MessageHeadersForeachFunc
    -- ^ /@func@/: callback function to run for each header
    -> m ()
messageHeadersForeach :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> MessageHeadersForeachFunc -> m ()
messageHeadersForeach 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersForeach"
        })


#endif

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

foreign import ccall "soup_message_headers_free" soup_message_headers_free :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO ()

-- | Frees /@hdrs@/.
messageHeadersFree ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m ()
messageHeadersFree :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m ()
messageHeadersFree 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_free 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 MessageHeadersFreeMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod MessageHeadersFreeMethodInfo MessageHeaders signature where
    overloadedMethod = messageHeadersFree

instance O.OverloadedMethodInfo MessageHeadersFreeMethodInfo MessageHeaders where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersFree",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersFree"
        })


#endif

-- method MessageHeaders::free_ranges
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ranges"
--           , argType = TInterface Name { namespace = "Soup" , name = "Range" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of #SoupRange"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_free_ranges" soup_message_headers_free_ranges :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr Soup.Range.Range ->                 -- ranges : TInterface (Name {namespace = "Soup", name = "Range"})
    IO ()

-- | Frees the array of ranges returned from 'GI.Soup.Structs.MessageHeaders.messageHeadersGetRanges'.
-- 
-- /Since: 2.26/
messageHeadersFreeRanges ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> Soup.Range.Range
    -- ^ /@ranges@/: an array of t'GI.Soup.Structs.Range.Range'
    -> m ()
messageHeadersFreeRanges :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Range -> m ()
messageHeadersFreeRanges 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersFreeRanges"
        })


#endif

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

foreign import ccall "soup_message_headers_get" soup_message_headers_get :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    IO CString

{-# DEPRECATED messageHeadersGet ["Use 'GI.Soup.Structs.MessageHeaders.messageHeadersGetOne' or","'GI.Soup.Structs.MessageHeaders.messageHeadersGetList' instead."] #-}
-- | Gets the value of header /@name@/ in /@hdrs@/.
-- 
-- This method was supposed to work correctly for both single-valued
-- and list-valued headers, but because some HTTP clients\/servers
-- mistakenly send multiple copies of headers that are supposed to be
-- single-valued, it sometimes returns incorrect results. To fix this,
-- the methods 'GI.Soup.Structs.MessageHeaders.messageHeadersGetOne' and
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersGetList' were introduced, so callers can
-- explicitly state which behavior they are expecting.
messageHeadersGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@name@/: header name
    -> m (Maybe T.Text)
    -- ^ __Returns:__ as with 'GI.Soup.Structs.MessageHeaders.messageHeadersGetList'.
messageHeadersGet :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> m (Maybe Text)
messageHeadersGet 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 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 MessageHeadersGetMethodInfo
instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.OverloadedMethod MessageHeadersGetMethodInfo MessageHeaders signature where
    overloadedMethod = messageHeadersGet

instance O.OverloadedMethodInfo MessageHeadersGetMethodInfo MessageHeaders where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Structs.MessageHeaders.messageHeadersGet",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGet"
        })


#endif

-- method MessageHeaders::get_content_disposition
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "disposition"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "return location for the\ndisposition-type, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "params"
--           , argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return\nlocation for the Content-Disposition parameters, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_content_disposition" soup_message_headers_get_content_disposition :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr CString ->                          -- disposition : TBasicType TUTF8
    Ptr (Ptr (GHashTable CString CString)) -> -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO CInt

-- | Looks up the \"Content-Disposition\" header in /@hdrs@/, parses it, and
-- returns its value in */@disposition@/ and */@params@/. /@params@/ can be
-- 'P.Nothing' if you are only interested in the disposition-type.
-- 
-- In HTTP, the most common use of this header is to set a
-- disposition-type of \"attachment\", to suggest to the browser that a
-- response should be saved to disk rather than displayed in the
-- browser. If /@params@/ contains a \"filename\" parameter, this is a
-- suggestion of a filename to use. (If the parameter value in the
-- header contains an absolute or relative path, libsoup will truncate
-- it down to just the final path component, so you do not need to
-- test this yourself.)
-- 
-- Content-Disposition is also used in \"multipart\/form-data\", however
-- this is handled automatically by t'GI.Soup.Structs.Multipart.Multipart' and the associated
-- form methods.
-- 
-- /Since: 2.26/
messageHeadersGetContentDisposition ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m ((Bool, T.Text, Map.Map T.Text T.Text))
    -- ^ __Returns:__ 'P.True' if /@hdrs@/ contains a \"Content-Disposition\"
    -- header, 'P.False' if not (in which case */@disposition@/ and */@params@/
    -- will be unchanged).
messageHeadersGetContentDisposition :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m (Bool, Text, Map Text Text)
messageHeadersGetContentDisposition 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetContentDisposition"
        })


#endif

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

foreign import ccall "soup_message_headers_get_content_length" soup_message_headers_get_content_length :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO Int64

-- | Gets the message body length that /@hdrs@/ declare. This will only
-- be non-0 if 'GI.Soup.Structs.MessageHeaders.messageHeadersGetEncoding' returns
-- 'GI.Soup.Enums.EncodingContentLength'.
messageHeadersGetContentLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m Int64
    -- ^ __Returns:__ the message body length declared by /@hdrs@/.
messageHeadersGetContentLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m Int64
messageHeadersGetContentLength 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetContentLength"
        })


#endif

-- method MessageHeaders::get_content_range
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType = TBasicType TInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return value for the start of the range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "end"
--           , argType = TBasicType TInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return value for the end of the range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "total_length"
--           , argType = TBasicType TInt64
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "return value for the total length of the\nresource, or %NULL if you don't care."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_content_range" soup_message_headers_get_content_range :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr Int64 ->                            -- start : TBasicType TInt64
    Ptr Int64 ->                            -- end : TBasicType TInt64
    Ptr Int64 ->                            -- total_length : TBasicType TInt64
    IO CInt

-- | Parses /@hdrs@/\'s Content-Range header and returns it in /@start@/,
-- /@end@/, and /@totalLength@/. If the total length field in the header
-- was specified as \"*\", then /@totalLength@/ will be set to -1.
-- 
-- /Since: 2.26/
messageHeadersGetContentRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m ((Bool, Int64, Int64, Int64))
    -- ^ __Returns:__ 'P.True' if /@hdrs@/ contained a \"Content-Range\" header
    -- containing a byte range which could be parsed, 'P.False' otherwise.
messageHeadersGetContentRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m (Bool, Int64, Int64, Int64)
messageHeadersGetContentRange 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetContentRange"
        })


#endif

-- method MessageHeaders::get_content_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "params"
--           , argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "\n  return location for the Content-Type parameters (eg, \"charset\"), or\n  %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_content_type" soup_message_headers_get_content_type :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr (Ptr (GHashTable CString CString)) -> -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO CString

-- | Looks up the \"Content-Type\" header in /@hdrs@/, parses it, and returns
-- its value in */@contentType@/ and */@params@/. /@params@/ can be 'P.Nothing' if you
-- are only interested in the content type itself.
-- 
-- /Since: 2.26/
messageHeadersGetContentType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m ((Maybe T.Text, Map.Map T.Text T.Text))
    -- ^ __Returns:__ a string with the value of the
    -- \"Content-Type\" header or 'P.Nothing' if /@hdrs@/ does not contain that
    -- header or it cannot be parsed (in which case */@params@/ will be
    -- unchanged).
messageHeadersGetContentType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m (Maybe Text, Map Text Text)
messageHeadersGetContentType 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetContentType"
        })


#endif

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

foreign import ccall "soup_message_headers_get_encoding" soup_message_headers_get_encoding :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO CUInt

-- | Gets the message body encoding that /@hdrs@/ declare. This may not
-- always correspond to the encoding used on the wire; eg, a HEAD
-- response may declare a Content-Length or Transfer-Encoding, but
-- it will never actually include a body.
messageHeadersGetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m Soup.Enums.Encoding
    -- ^ __Returns:__ the encoding declared by /@hdrs@/.
messageHeadersGetEncoding :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m Encoding
messageHeadersGetEncoding 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetEncoding"
        })


#endif

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

foreign import ccall "soup_message_headers_get_expectations" soup_message_headers_get_expectations :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO CUInt

-- | Gets the expectations declared by /@hdrs@/\'s \"Expect\" header.
-- Currently this will either be 'GI.Soup.Flags.ExpectationContinue' or
-- 'GI.Soup.Flags.ExpectationUnrecognized'.
messageHeadersGetExpectations ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m [Soup.Flags.Expectation]
    -- ^ __Returns:__ the contents of /@hdrs@/\'s \"Expect\" header
messageHeadersGetExpectations :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m [Expectation]
messageHeadersGetExpectations 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetExpectations"
        })


#endif

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

foreign import ccall "soup_message_headers_get_headers_type" soup_message_headers_get_headers_type :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO CUInt

-- | Gets the type of headers.
-- 
-- /Since: 2.50/
messageHeadersGetHeadersType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> m Soup.Enums.MessageHeadersType
    -- ^ __Returns:__ the header\'s type.
messageHeadersGetHeadersType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> m MessageHeadersType
messageHeadersGetHeadersType 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetHeadersType"
        })


#endif

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

foreign import ccall "soup_message_headers_get_list" soup_message_headers_get_list :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    IO CString

-- | Gets the value of header /@name@/ in /@hdrs@/. Use this for headers whose
-- values are comma-delimited lists, and which are therefore allowed
-- to appear multiple times in the headers. For non-list-valued
-- headers, use 'GI.Soup.Structs.MessageHeaders.messageHeadersGetOne'.
-- 
-- If /@name@/ appears multiple times in /@hdrs@/,
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersGetList' will concatenate all of the values
-- together, separated by commas. This is sometimes awkward to parse
-- (eg, WWW-Authenticate, Set-Cookie), but you have to be able to deal
-- with it anyway, because the HTTP spec explicitly states that this
-- transformation is allowed, and so an upstream proxy could do the
-- same thing.
-- 
-- /Since: 2.28/
messageHeadersGetList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@name@/: header name
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the header\'s value or 'P.Nothing' if not found.
messageHeadersGetList :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> m (Maybe Text)
messageHeadersGetList 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetList"
        })


#endif

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

foreign import ccall "soup_message_headers_get_one" soup_message_headers_get_one :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    IO CString

-- | Gets the value of header /@name@/ in /@hdrs@/. Use this for headers whose
-- values are \<emphasis>not\<\/emphasis> comma-delimited lists, and
-- which therefore can only appear at most once in the headers. For
-- list-valued headers, use 'GI.Soup.Structs.MessageHeaders.messageHeadersGetList'.
-- 
-- If /@hdrs@/ does erroneously contain multiple copies of the header, it
-- is not defined which one will be returned. (Ideally, it will return
-- whichever one makes libsoup most compatible with other HTTP
-- implementations.)
-- 
-- /Since: 2.28/
messageHeadersGetOne ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@name@/: header name
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the header\'s value or 'P.Nothing' if not found.
messageHeadersGetOne :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> m (Maybe Text)
messageHeadersGetOne 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetOne"
        })


#endif

-- method MessageHeaders::get_ranges
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "total_length"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the total_length of the response body"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ranges"
--           , argType =
--               TCArray
--                 False
--                 (-1)
--                 3
--                 (TInterface Name { namespace = "Soup" , name = "Range" })
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return location for an array\nof #SoupRange"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the length of the returned array"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "length"
--              , argType = TBasicType TInt
--              , direction = DirectionOut
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the length of the returned array"
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferEverything
--              }
--          ]
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_get_ranges" soup_message_headers_get_ranges :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- total_length : TBasicType TInt64
    Ptr (Ptr Soup.Range.Range) ->           -- ranges : TCArray False (-1) 3 (TInterface (Name {namespace = "Soup", name = "Range"}))
    Ptr Int32 ->                            -- length : TBasicType TInt
    IO CInt

-- | Parses /@hdrs@/\'s Range header and returns an array of the requested
-- byte ranges. The returned array must be freed with
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersFreeRanges'.
-- 
-- If /@totalLength@/ is non-0, its value will be used to adjust the
-- returned ranges to have explicit start and end values, and the
-- returned ranges will be sorted and non-overlapping. If
-- /@totalLength@/ is 0, then some ranges may have an end value of -1,
-- as described under t'GI.Soup.Structs.Range.Range', and some of the ranges may be
-- redundant.
-- 
-- Beware that even if given a /@totalLength@/, this function does not
-- check that the ranges are satisfiable.
-- 
-- \<note>\<para>
-- t'GI.Soup.Objects.Server.Server' has built-in handling for range requests. If your
-- server handler returns a 'GI.Soup.Enums.StatusOk' response containing the
-- complete response body (rather than pausing the message and
-- returning some of the response body later), and there is a Range
-- header in the request, then libsoup will automatically convert the
-- response to a 'GI.Soup.Enums.StatusPartialContent' response containing only
-- the range(s) requested by the client.
-- 
-- The only time you need to process the Range header yourself is if
-- either you need to stream the response body rather than returning
-- it all at once, or you do not already have the complete response
-- body available, and only want to generate the parts that were
-- actually requested by the client.
-- \<\/para>\<\/note>
-- 
-- /Since: 2.26/
messageHeadersGetRanges ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> Int64
    -- ^ /@totalLength@/: the total_length of the response body
    -> m ((Bool, [Soup.Range.Range]))
    -- ^ __Returns:__ 'P.True' if /@hdrs@/ contained a syntactically-valid
    -- \"Range\" header, 'P.False' otherwise (in which case /@range@/ and /@length@/
    -- will not be set).
messageHeadersGetRanges :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Int64 -> m (Bool, [Range])
messageHeadersGetRanges 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersGetRanges"
        })


#endif

-- method MessageHeaders::header_contains
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "header name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "token"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "token to look for" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_header_contains" soup_message_headers_header_contains :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- token : TBasicType TUTF8
    IO CInt

-- | Checks whether the list-valued header /@name@/ is present in /@hdrs@/,
-- and contains a case-insensitive match for /@token@/.
-- 
-- (If /@name@/ is present in /@hdrs@/, then this is equivalent to calling
-- 'GI.Soup.Functions.headerContains' on its value.)
-- 
-- /Since: 2.50/
messageHeadersHeaderContains ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@name@/: header name
    -> T.Text
    -- ^ /@token@/: token to look for
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the header is present and contains /@token@/,
    --   'P.False' otherwise.
messageHeadersHeaderContains :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> Text -> m Bool
messageHeadersHeaderContains 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersHeaderContains"
        })


#endif

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

foreign import ccall "soup_message_headers_header_equals" soup_message_headers_header_equals :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO CInt

-- | Checks whether the header /@name@/ is present in /@hdrs@/ and is
-- (case-insensitively) equal to /@value@/.
-- 
-- /Since: 2.50/
messageHeadersHeaderEquals ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@name@/: header name
    -> T.Text
    -- ^ /@value@/: expected value
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the header is present and its value is
    --   /@value@/, 'P.False' otherwise.
messageHeadersHeaderEquals :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> Text -> m Bool
messageHeadersHeaderEquals 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersHeaderEquals"
        })


#endif

-- method MessageHeaders::remove
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the header name to remove"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_remove" soup_message_headers_remove :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    IO ()

-- | Removes /@name@/ from /@hdrs@/. If there are multiple values for /@name@/,
-- they are all removed.
messageHeadersRemove ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@name@/: the header name to remove
    -> m ()
messageHeadersRemove :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> m ()
messageHeadersRemove 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersRemove"
        })


#endif

-- method MessageHeaders::replace
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the header name to replace"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the new value of @name"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_replace" soup_message_headers_replace :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO ()

-- | Replaces the value of the header /@name@/ in /@hdrs@/ with /@value@/. (See
-- also 'GI.Soup.Structs.MessageHeaders.messageHeadersAppend'.)
-- 
-- The caller is expected to make sure that /@name@/ and /@value@/ are
-- syntactically correct.
messageHeadersReplace ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@name@/: the header name to replace
    -> T.Text
    -- ^ /@value@/: the new value of /@name@/
    -> m ()
messageHeadersReplace :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> Text -> m ()
messageHeadersReplace 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersReplace"
        })


#endif

-- method MessageHeaders::set_content_disposition
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "disposition"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the disposition-type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "params"
--           , argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "additional\nparameters, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_content_disposition" soup_message_headers_set_content_disposition :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- disposition : TBasicType TUTF8
    Ptr (GHashTable CString CString) ->     -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO ()

-- | Sets the \"Content-Disposition\" header in /@hdrs@/ to /@disposition@/,
-- optionally with additional parameters specified in /@params@/.
-- 
-- See 'GI.Soup.Structs.MessageHeaders.messageHeadersGetContentDisposition' for a discussion
-- of how Content-Disposition is used in HTTP.
-- 
-- /Since: 2.26/
messageHeadersSetContentDisposition ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@disposition@/: the disposition-type
    -> Maybe (Map.Map T.Text T.Text)
    -- ^ /@params@/: additional
    -- parameters, or 'P.Nothing'
    -> m ()
messageHeadersSetContentDisposition :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> Maybe (Map Text Text) -> m ()
messageHeadersSetContentDisposition 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetContentDisposition"
        })


#endif

-- method MessageHeaders::set_content_length
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_length"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message body length"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_content_length" soup_message_headers_set_content_length :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- content_length : TBasicType TInt64
    IO ()

-- | Sets the message body length that /@hdrs@/ will declare, and sets
-- /@hdrs@/\'s encoding to 'GI.Soup.Enums.EncodingContentLength'.
-- 
-- You do not normally need to call this; if /@hdrs@/ is set to use
-- Content-Length encoding, libsoup will automatically set its
-- Content-Length header for you immediately before sending the
-- headers. One situation in which this method is useful is when
-- generating the response to a HEAD request; Calling
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersSetContentLength' allows you to put the
-- correct content length into the response without needing to waste
-- memory by filling in a response body which won\'t actually be sent.
messageHeadersSetContentLength ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> Int64
    -- ^ /@contentLength@/: the message body length
    -> m ()
messageHeadersSetContentLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Int64 -> m ()
messageHeadersSetContentLength 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetContentLength"
        })


#endif

-- method MessageHeaders::set_content_range
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the start of the range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the end of the range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "total_length"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "the total length of the resource, or -1 if unknown"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_content_range" soup_message_headers_set_content_range :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- start : TBasicType TInt64
    Int64 ->                                -- end : TBasicType TInt64
    Int64 ->                                -- total_length : TBasicType TInt64
    IO ()

-- | Sets /@hdrs@/\'s Content-Range header according to the given values.
-- (Note that /@totalLength@/ is the total length of the entire resource
-- that this is a range of, not simply /@end@/ - /@start@/ + 1.)
-- 
-- \<note>\<para>
-- t'GI.Soup.Objects.Server.Server' has built-in handling for range requests, and you do
-- not normally need to call this function youself. See
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersGetRanges' for more details.
-- \<\/para>\<\/note>
-- 
-- /Since: 2.26/
messageHeadersSetContentRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> Int64
    -- ^ /@start@/: the start of the range
    -> Int64
    -- ^ /@end@/: the end of the range
    -> Int64
    -- ^ /@totalLength@/: the total length of the resource, or -1 if unknown
    -> m ()
messageHeadersSetContentRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Int64 -> Int64 -> Int64 -> m ()
messageHeadersSetContentRange 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetContentRange"
        })


#endif

-- method MessageHeaders::set_content_type
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_type"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the MIME type" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "params"
--           , argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "additional\nparameters, or %NULL"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_content_type" soup_message_headers_set_content_type :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CString ->                              -- content_type : TBasicType TUTF8
    Ptr (GHashTable CString CString) ->     -- params : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO ()

-- | Sets the \"Content-Type\" header in /@hdrs@/ to /@contentType@/,
-- optionally with additional parameters specified in /@params@/.
-- 
-- /Since: 2.26/
messageHeadersSetContentType ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> T.Text
    -- ^ /@contentType@/: the MIME type
    -> Maybe (Map.Map T.Text T.Text)
    -- ^ /@params@/: additional
    -- parameters, or 'P.Nothing'
    -> m ()
messageHeadersSetContentType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Text -> Maybe (Map Text Text) -> m ()
messageHeadersSetContentType 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetContentType"
        })


#endif

-- method MessageHeaders::set_encoding
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "encoding"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Encoding" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupEncoding" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_encoding" soup_message_headers_set_encoding :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CUInt ->                                -- encoding : TInterface (Name {namespace = "Soup", name = "Encoding"})
    IO ()

-- | Sets the message body encoding that /@hdrs@/ will declare. In particular,
-- you should use this if you are going to send a request or response in
-- chunked encoding.
messageHeadersSetEncoding ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> Soup.Enums.Encoding
    -- ^ /@encoding@/: a t'GI.Soup.Enums.Encoding'
    -> m ()
messageHeadersSetEncoding :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Encoding -> m ()
messageHeadersSetEncoding 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetEncoding"
        })


#endif

-- method MessageHeaders::set_expectations
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expectations"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Expectation" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the expectations to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_expectations" soup_message_headers_set_expectations :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    CUInt ->                                -- expectations : TInterface (Name {namespace = "Soup", name = "Expectation"})
    IO ()

-- | Sets /@hdrs@/\'s \"Expect\" header according to /@expectations@/.
-- 
-- Currently 'GI.Soup.Flags.ExpectationContinue' is the only known expectation
-- value. You should set this value on a request if you are sending a
-- large message body (eg, via POST or PUT), and want to give the
-- server a chance to reject the request after seeing just the headers
-- (eg, because it will require authentication before allowing you to
-- post, or because you\'re POSTing to a URL that doesn\'t exist). This
-- saves you from having to transmit the large request body when the
-- server is just going to ignore it anyway.
messageHeadersSetExpectations ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> [Soup.Flags.Expectation]
    -- ^ /@expectations@/: the expectations to set
    -> m ()
messageHeadersSetExpectations :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> [Expectation] -> m ()
messageHeadersSetExpectations 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetExpectations"
        })


#endif

-- method MessageHeaders::set_range
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "start"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the start of the range to request"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "end"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the end of the range to request"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_range" soup_message_headers_set_range :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Int64 ->                                -- start : TBasicType TInt64
    Int64 ->                                -- end : TBasicType TInt64
    IO ()

-- | Sets /@hdrs@/\'s Range header to request the indicated range.
-- /@start@/ and /@end@/ are interpreted as in a t'GI.Soup.Structs.Range.Range'.
-- 
-- If you need to request multiple ranges, use
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersSetRanges'.
-- 
-- /Since: 2.26/
messageHeadersSetRange ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> Int64
    -- ^ /@start@/: the start of the range to request
    -> Int64
    -- ^ /@end@/: the end of the range to request
    -> m ()
messageHeadersSetRange :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Int64 -> Int64 -> m ()
messageHeadersSetRange 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetRange"
        })


#endif

-- method MessageHeaders::set_ranges
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "hdrs"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessageHeaders"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ranges"
--           , argType = TInterface Name { namespace = "Soup" , name = "Range" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an array of #SoupRange"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the length of @range"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_message_headers_set_ranges" soup_message_headers_set_ranges :: 
    Ptr MessageHeaders ->                   -- hdrs : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr Soup.Range.Range ->                 -- ranges : TInterface (Name {namespace = "Soup", name = "Range"})
    Int32 ->                                -- length : TBasicType TInt
    IO ()

-- | Sets /@hdrs@/\'s Range header to request the indicated ranges. (If you
-- only want to request a single range, you can use
-- 'GI.Soup.Structs.MessageHeaders.messageHeadersSetRange'.)
-- 
-- /Since: 2.26/
messageHeadersSetRanges ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    MessageHeaders
    -- ^ /@hdrs@/: a t'GI.Soup.Structs.MessageHeaders.MessageHeaders'
    -> Soup.Range.Range
    -- ^ /@ranges@/: an array of t'GI.Soup.Structs.Range.Range'
    -> Int32
    -- ^ /@length@/: the length of /@range@/
    -> m ()
messageHeadersSetRanges :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
MessageHeaders -> Range -> Int32 -> m ()
messageHeadersSetRanges 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-2.4.26/docs/GI-Soup-Structs-MessageHeaders.html#v:messageHeadersSetRanges"
        })


#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveMessageHeadersMethod (t :: Symbol) (o :: *) :: * where
    ResolveMessageHeadersMethod "append" o = MessageHeadersAppendMethodInfo
    ResolveMessageHeadersMethod "cleanConnectionHeaders" o = MessageHeadersCleanConnectionHeadersMethodInfo
    ResolveMessageHeadersMethod "clear" o = MessageHeadersClearMethodInfo
    ResolveMessageHeadersMethod "foreach" o = MessageHeadersForeachMethodInfo
    ResolveMessageHeadersMethod "free" o = MessageHeadersFreeMethodInfo
    ResolveMessageHeadersMethod "freeRanges" o = MessageHeadersFreeRangesMethodInfo
    ResolveMessageHeadersMethod "get" o = MessageHeadersGetMethodInfo
    ResolveMessageHeadersMethod "headerContains" o = MessageHeadersHeaderContainsMethodInfo
    ResolveMessageHeadersMethod "headerEquals" o = MessageHeadersHeaderEqualsMethodInfo
    ResolveMessageHeadersMethod "remove" o = MessageHeadersRemoveMethodInfo
    ResolveMessageHeadersMethod "replace" o = MessageHeadersReplaceMethodInfo
    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