{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (garetxe@gmail.com) The HTTP message headers associated with a request or response. -} module GI.Soup.Structs.MessageHeaders ( -- * Exported types MessageHeaders(..) , noMessageHeaders , -- * Methods -- ** append #method:append# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersAppendMethodInfo , #endif messageHeadersAppend , -- ** cleanConnectionHeaders #method:cleanConnectionHeaders# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersCleanConnectionHeadersMethodInfo, #endif messageHeadersCleanConnectionHeaders , -- ** clear #method:clear# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersClearMethodInfo , #endif messageHeadersClear , -- ** foreach #method:foreach# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersForeachMethodInfo , #endif messageHeadersForeach , -- ** free #method:free# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersFreeMethodInfo , #endif messageHeadersFree , -- ** freeRanges #method:freeRanges# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersFreeRangesMethodInfo , #endif messageHeadersFreeRanges , -- ** get #method:get# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetMethodInfo , #endif messageHeadersGet , -- ** getContentDisposition #method:getContentDisposition# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetContentDispositionMethodInfo, #endif messageHeadersGetContentDisposition , -- ** getContentLength #method:getContentLength# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetContentLengthMethodInfo, #endif messageHeadersGetContentLength , -- ** getContentRange #method:getContentRange# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetContentRangeMethodInfo , #endif messageHeadersGetContentRange , -- ** getContentType #method:getContentType# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetContentTypeMethodInfo , #endif messageHeadersGetContentType , -- ** getEncoding #method:getEncoding# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetEncodingMethodInfo , #endif messageHeadersGetEncoding , -- ** getExpectations #method:getExpectations# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetExpectationsMethodInfo , #endif messageHeadersGetExpectations , -- ** getHeadersType #method:getHeadersType# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetHeadersTypeMethodInfo , #endif messageHeadersGetHeadersType , -- ** getList #method:getList# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetListMethodInfo , #endif messageHeadersGetList , -- ** getOne #method:getOne# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetOneMethodInfo , #endif messageHeadersGetOne , -- ** getRanges #method:getRanges# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersGetRangesMethodInfo , #endif messageHeadersGetRanges , -- ** headerContains #method:headerContains# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersHeaderContainsMethodInfo , #endif messageHeadersHeaderContains , -- ** headerEquals #method:headerEquals# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersHeaderEqualsMethodInfo , #endif messageHeadersHeaderEquals , -- ** new #method:new# messageHeadersNew , -- ** remove #method:remove# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersRemoveMethodInfo , #endif messageHeadersRemove , -- ** replace #method:replace# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersReplaceMethodInfo , #endif messageHeadersReplace , -- ** setContentDisposition #method:setContentDisposition# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersSetContentDispositionMethodInfo, #endif messageHeadersSetContentDisposition , -- ** setContentLength #method:setContentLength# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersSetContentLengthMethodInfo, #endif messageHeadersSetContentLength , -- ** setContentRange #method:setContentRange# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersSetContentRangeMethodInfo , #endif messageHeadersSetContentRange , -- ** setContentType #method:setContentType# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersSetContentTypeMethodInfo , #endif messageHeadersSetContentType , -- ** setEncoding #method:setEncoding# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersSetEncodingMethodInfo , #endif messageHeadersSetEncoding , -- ** setExpectations #method:setExpectations# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersSetExpectationsMethodInfo , #endif messageHeadersSetExpectations , -- ** setRange #method:setRange# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) MessageHeadersSetRangeMethodInfo , #endif messageHeadersSetRange , -- ** setRanges #method:setRanges# #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) 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.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack 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 GI.Soup.Callbacks as Soup.Callbacks import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums import {-# SOURCE #-} qualified GI.Soup.Flags as Soup.Flags import {-# SOURCE #-} qualified GI.Soup.Structs.Range as Soup.Range newtype MessageHeaders = MessageHeaders (ManagedPtr MessageHeaders) foreign import ccall "soup_message_headers_get_type" c_soup_message_headers_get_type :: IO GType instance BoxedObject MessageHeaders where boxedType _ = c_soup_message_headers_get_type noMessageHeaders :: Maybe MessageHeaders noMessageHeaders = Nothing #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders'. ('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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} messageHeadersNew type_ = liftIO $ do let type_' = (fromIntegral . fromEnum) type_ result <- soup_message_headers_new type_' checkUnexpectedReturnNULL "messageHeadersNew" result result' <- (wrapBoxed MessageHeaders) result return result' #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) #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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@name@/: the header name to add -} -> T.Text {- ^ /@value@/: the new value of /@name@/ -} -> m () messageHeadersAppend hdrs name value = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs name' <- textToCString name value' <- textToCString value soup_message_headers_append hdrs' name' value' touchManagedPtr hdrs freeMem name' freeMem value' return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersAppendMethodInfo instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.MethodInfo MessageHeadersAppendMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m () messageHeadersCleanConnectionHeaders hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs soup_message_headers_clean_connection_headers hdrs' touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersCleanConnectionHeadersMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageHeadersCleanConnectionHeadersMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m () messageHeadersClear hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs soup_message_headers_clear hdrs' touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersClearMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageHeadersClearMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> Soup.Callbacks.MessageHeadersForeachFunc {- ^ /@func@/: callback function to run for each header -} -> m () messageHeadersForeach hdrs func = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs func' <- Soup.Callbacks.mk_MessageHeadersForeachFunc (Soup.Callbacks.wrap_MessageHeadersForeachFunc Nothing (Soup.Callbacks.drop_closures_MessageHeadersForeachFunc func)) let userData = nullPtr soup_message_headers_foreach hdrs' func' userData safeFreeFunPtr $ castFunPtrToPtr func' touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersForeachMethodInfo instance (signature ~ (Soup.Callbacks.MessageHeadersForeachFunc -> m ()), MonadIO m) => O.MethodInfo MessageHeadersForeachMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m () messageHeadersFree hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs soup_message_headers_free hdrs' touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersFreeMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo MessageHeadersFreeMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> Soup.Range.Range {- ^ /@ranges@/: an array of 'GI.Soup.Structs.Range.Range' -} -> m () messageHeadersFreeRanges hdrs ranges = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs ranges' <- unsafeManagedPtrGetPtr ranges soup_message_headers_free_ranges hdrs' ranges' touchManagedPtr hdrs touchManagedPtr ranges return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersFreeRangesMethodInfo instance (signature ~ (Soup.Range.Range -> m ()), MonadIO m) => O.MethodInfo MessageHeadersFreeRangesMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@name@/: header name -} -> m (Maybe T.Text) {- ^ __Returns:__ as with 'GI.Soup.Structs.MessageHeaders.messageHeadersGetList'. -} messageHeadersGet hdrs name = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs name' <- textToCString name result <- soup_message_headers_get hdrs' name' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr hdrs freeMem name' return maybeResult #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetMethodInfo instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo MessageHeadersGetMethodInfo MessageHeaders signature where overloadedMethod _ = 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 '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 'GI.Soup.Structs.Multipart.Multipart' and the associated form methods. @since 2.26 -} messageHeadersGetContentDisposition :: (B.CallStack.HasCallStack, MonadIO m) => MessageHeaders {- ^ /@hdrs@/: a 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m ((Bool, T.Text, Map.Map T.Text T.Text)) {- ^ __Returns:__ 'True' if /@hdrs@/ contains a \"Content-Disposition\" header, 'False' if not (in which case */@disposition@/ and */@params@/ will be unchanged). -} messageHeadersGetContentDisposition hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs disposition <- allocMem :: IO (Ptr CString) params <- allocMem :: IO (Ptr (Ptr (GHashTable CString CString))) result <- soup_message_headers_get_content_disposition hdrs' disposition params let result' = (/= 0) result disposition' <- peek disposition disposition'' <- cstringToText disposition' freeMem disposition' params' <- peek params params'' <- unpackGHashTable params' let params''' = mapFirst cstringUnpackPtr params'' params'''' <- mapFirstA cstringToText params''' let params''''' = mapSecond cstringUnpackPtr params'''' params'''''' <- mapSecondA cstringToText params''''' let params''''''' = Map.fromList params'''''' unrefGHashTable params' touchManagedPtr hdrs freeMem disposition freeMem params return (result', disposition'', params''''''') #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetContentDispositionMethodInfo instance (signature ~ (m ((Bool, T.Text, Map.Map T.Text T.Text))), MonadIO m) => O.MethodInfo MessageHeadersGetContentDispositionMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m Int64 {- ^ __Returns:__ the message body length declared by /@hdrs@/. -} messageHeadersGetContentLength hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs result <- soup_message_headers_get_content_length hdrs' touchManagedPtr hdrs return result #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetContentLengthMethodInfo instance (signature ~ (m Int64), MonadIO m) => O.MethodInfo MessageHeadersGetContentLengthMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m ((Bool, Int64, Int64, Int64)) {- ^ __Returns:__ 'True' if /@hdrs@/ contained a \"Content-Range\" header containing a byte range which could be parsed, 'False' otherwise. -} messageHeadersGetContentRange hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs start <- allocMem :: IO (Ptr Int64) end <- allocMem :: IO (Ptr Int64) totalLength <- allocMem :: IO (Ptr Int64) result <- soup_message_headers_get_content_range hdrs' start end totalLength let result' = (/= 0) result start' <- peek start end' <- peek end totalLength' <- peek totalLength touchManagedPtr hdrs freeMem start freeMem end freeMem totalLength return (result', start', end', totalLength') #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetContentRangeMethodInfo instance (signature ~ (m ((Bool, Int64, Int64, Int64))), MonadIO m) => O.MethodInfo MessageHeadersGetContentRangeMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'Nothing' if you are only interested in the content type itself. @since 2.26 -} messageHeadersGetContentType :: (B.CallStack.HasCallStack, MonadIO m) => MessageHeaders {- ^ /@hdrs@/: a '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 'Nothing' if /@hdrs@/ does not contain that header or it cannot be parsed (in which case */@params@/ will be unchanged). -} messageHeadersGetContentType hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs params <- allocMem :: IO (Ptr (Ptr (GHashTable CString CString))) result <- soup_message_headers_get_content_type hdrs' params maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' params' <- peek params params'' <- unpackGHashTable params' let params''' = mapFirst cstringUnpackPtr params'' params'''' <- mapFirstA cstringToText params''' let params''''' = mapSecond cstringUnpackPtr params'''' params'''''' <- mapSecondA cstringToText params''''' let params''''''' = Map.fromList params'''''' unrefGHashTable params' touchManagedPtr hdrs freeMem params return (maybeResult, params''''''') #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetContentTypeMethodInfo instance (signature ~ (m ((Maybe T.Text, Map.Map T.Text T.Text))), MonadIO m) => O.MethodInfo MessageHeadersGetContentTypeMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m Soup.Enums.Encoding {- ^ __Returns:__ the encoding declared by /@hdrs@/. -} messageHeadersGetEncoding hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs result <- soup_message_headers_get_encoding hdrs' let result' = (toEnum . fromIntegral) result touchManagedPtr hdrs return result' #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetEncodingMethodInfo instance (signature ~ (m Soup.Enums.Encoding), MonadIO m) => O.MethodInfo MessageHeadersGetEncodingMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m [Soup.Flags.Expectation] {- ^ __Returns:__ the contents of /@hdrs@/\'s \"Expect\" header -} messageHeadersGetExpectations hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs result <- soup_message_headers_get_expectations hdrs' let result' = wordToGFlags result touchManagedPtr hdrs return result' #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetExpectationsMethodInfo instance (signature ~ (m [Soup.Flags.Expectation]), MonadIO m) => O.MethodInfo MessageHeadersGetExpectationsMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> m Soup.Enums.MessageHeadersType {- ^ __Returns:__ the header\'s type. -} messageHeadersGetHeadersType hdrs = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs result <- soup_message_headers_get_headers_type hdrs' let result' = (toEnum . fromIntegral) result touchManagedPtr hdrs return result' #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetHeadersTypeMethodInfo instance (signature ~ (m Soup.Enums.MessageHeadersType), MonadIO m) => O.MethodInfo MessageHeadersGetHeadersTypeMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@name@/: header name -} -> m (Maybe T.Text) {- ^ __Returns:__ the header\'s value or 'Nothing' if not found. -} messageHeadersGetList hdrs name = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs name' <- textToCString name result <- soup_message_headers_get_list hdrs' name' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr hdrs freeMem name' return maybeResult #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetListMethodInfo instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo MessageHeadersGetListMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@name@/: header name -} -> m (Maybe T.Text) {- ^ __Returns:__ the header\'s value or 'Nothing' if not found. -} messageHeadersGetOne hdrs name = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs name' <- textToCString name result <- soup_message_headers_get_one hdrs' name' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr hdrs freeMem name' return maybeResult #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetOneMethodInfo instance (signature ~ (T.Text -> m (Maybe T.Text)), MonadIO m) => O.MethodInfo MessageHeadersGetOneMethodInfo MessageHeaders signature where overloadedMethod _ = 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 '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> '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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> Int64 {- ^ /@totalLength@/: the total_length of the response body -} -> m ((Bool, [Soup.Range.Range])) {- ^ __Returns:__ 'True' if /@hdrs@/ contained a syntactically-valid \"Range\" header, 'False' otherwise (in which case /@range@/ and /@length@/ will not be set). -} messageHeadersGetRanges hdrs totalLength = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs ranges <- allocMem :: IO (Ptr (Ptr Soup.Range.Range)) length_ <- allocMem :: IO (Ptr Int32) result <- soup_message_headers_get_ranges hdrs' totalLength ranges length_ length_' <- peek length_ let result' = (/= 0) result ranges' <- peek ranges ranges'' <- (unpackBlockArrayWithLength 16 length_') ranges' ranges''' <- mapM (wrapPtr Soup.Range.Range) ranges'' freeMem ranges' touchManagedPtr hdrs freeMem ranges freeMem length_ return (result', ranges''') #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersGetRangesMethodInfo instance (signature ~ (Int64 -> m ((Bool, [Soup.Range.Range]))), MonadIO m) => O.MethodInfo MessageHeadersGetRangesMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@name@/: header name -} -> T.Text {- ^ /@token@/: token to look for -} -> m Bool {- ^ __Returns:__ 'True' if the header is present and contains /@token@/, 'False' otherwise. -} messageHeadersHeaderContains hdrs name token = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs name' <- textToCString name token' <- textToCString token result <- soup_message_headers_header_contains hdrs' name' token' let result' = (/= 0) result touchManagedPtr hdrs freeMem name' freeMem token' return result' #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersHeaderContainsMethodInfo instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => O.MethodInfo MessageHeadersHeaderContainsMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@name@/: header name -} -> T.Text {- ^ /@value@/: expected value -} -> m Bool {- ^ __Returns:__ 'True' if the header is present and its value is /@value@/, 'False' otherwise. -} messageHeadersHeaderEquals hdrs name value = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs name' <- textToCString name value' <- textToCString value result <- soup_message_headers_header_equals hdrs' name' value' let result' = (/= 0) result touchManagedPtr hdrs freeMem name' freeMem value' return result' #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersHeaderEqualsMethodInfo instance (signature ~ (T.Text -> T.Text -> m Bool), MonadIO m) => O.MethodInfo MessageHeadersHeaderEqualsMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@name@/: the header name to remove -} -> m () messageHeadersRemove hdrs name = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs name' <- textToCString name soup_message_headers_remove hdrs' name' touchManagedPtr hdrs freeMem name' return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersRemoveMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m) => O.MethodInfo MessageHeadersRemoveMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@name@/: the header name to replace -} -> T.Text {- ^ /@value@/: the new value of /@name@/ -} -> m () messageHeadersReplace hdrs name value = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs name' <- textToCString name value' <- textToCString value soup_message_headers_replace hdrs' name' value' touchManagedPtr hdrs freeMem name' freeMem value' return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersReplaceMethodInfo instance (signature ~ (T.Text -> T.Text -> m ()), MonadIO m) => O.MethodInfo MessageHeadersReplaceMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@disposition@/: the disposition-type -} -> Maybe (Map.Map T.Text T.Text) {- ^ /@params@/: additional parameters, or 'Nothing' -} -> m () messageHeadersSetContentDisposition hdrs disposition params = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs disposition' <- textToCString disposition maybeParams <- case params of Nothing -> return nullPtr Just jParams -> do let jParams' = Map.toList jParams jParams'' <- mapFirstA textToCString jParams' jParams''' <- mapSecondA textToCString jParams'' let jParams'''' = mapFirst cstringPackPtr jParams''' let jParams''''' = mapSecond cstringPackPtr jParams'''' jParams'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) jParams''''' return jParams'''''' soup_message_headers_set_content_disposition hdrs' disposition' maybeParams touchManagedPtr hdrs freeMem disposition' unrefGHashTable maybeParams return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersSetContentDispositionMethodInfo instance (signature ~ (T.Text -> Maybe (Map.Map T.Text T.Text) -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetContentDispositionMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> Int64 {- ^ /@contentLength@/: the message body length -} -> m () messageHeadersSetContentLength hdrs contentLength = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs soup_message_headers_set_content_length hdrs' contentLength touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersSetContentLengthMethodInfo instance (signature ~ (Int64 -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetContentLengthMethodInfo MessageHeaders signature where overloadedMethod _ = 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> '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 '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 hdrs start end totalLength = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs soup_message_headers_set_content_range hdrs' start end totalLength touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersSetContentRangeMethodInfo instance (signature ~ (Int64 -> Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetContentRangeMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> T.Text {- ^ /@contentType@/: the MIME type -} -> Maybe (Map.Map T.Text T.Text) {- ^ /@params@/: additional parameters, or 'Nothing' -} -> m () messageHeadersSetContentType hdrs contentType params = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs contentType' <- textToCString contentType maybeParams <- case params of Nothing -> return nullPtr Just jParams -> do let jParams' = Map.toList jParams jParams'' <- mapFirstA textToCString jParams' jParams''' <- mapSecondA textToCString jParams'' let jParams'''' = mapFirst cstringPackPtr jParams''' let jParams''''' = mapSecond cstringPackPtr jParams'''' jParams'''''' <- packGHashTable gStrHash gStrEqual (Just ptr_to_g_free) (Just ptr_to_g_free) jParams''''' return jParams'''''' soup_message_headers_set_content_type hdrs' contentType' maybeParams touchManagedPtr hdrs freeMem contentType' unrefGHashTable maybeParams return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersSetContentTypeMethodInfo instance (signature ~ (T.Text -> Maybe (Map.Map T.Text T.Text) -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetContentTypeMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> Soup.Enums.Encoding {- ^ /@encoding@/: a 'GI.Soup.Enums.Encoding' -} -> m () messageHeadersSetEncoding hdrs encoding = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs let encoding' = (fromIntegral . fromEnum) encoding soup_message_headers_set_encoding hdrs' encoding' touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersSetEncodingMethodInfo instance (signature ~ (Soup.Enums.Encoding -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetEncodingMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> [Soup.Flags.Expectation] {- ^ /@expectations@/: the expectations to set -} -> m () messageHeadersSetExpectations hdrs expectations = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs let expectations' = gflagsToWord expectations soup_message_headers_set_expectations hdrs' expectations' touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersSetExpectationsMethodInfo instance (signature ~ ([Soup.Flags.Expectation] -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetExpectationsMethodInfo MessageHeaders signature where overloadedMethod _ = 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 '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 '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 hdrs start end = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs soup_message_headers_set_range hdrs' start end touchManagedPtr hdrs return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersSetRangeMethodInfo instance (signature ~ (Int64 -> Int64 -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetRangeMethodInfo MessageHeaders signature where overloadedMethod _ = 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 'GI.Soup.Structs.MessageHeaders.MessageHeaders' -} -> Soup.Range.Range {- ^ /@ranges@/: an array of 'GI.Soup.Structs.Range.Range' -} -> Int32 {- ^ /@length@/: the length of /@range@/ -} -> m () messageHeadersSetRanges hdrs ranges length_ = liftIO $ do hdrs' <- unsafeManagedPtrGetPtr hdrs ranges' <- unsafeManagedPtrGetPtr ranges soup_message_headers_set_ranges hdrs' ranges' length_ touchManagedPtr hdrs touchManagedPtr ranges return () #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) data MessageHeadersSetRangesMethodInfo instance (signature ~ (Soup.Range.Range -> Int32 -> m ()), MonadIO m) => O.MethodInfo MessageHeadersSetRangesMethodInfo MessageHeaders signature where overloadedMethod _ = messageHeadersSetRanges #endif #if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__) 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.MethodInfo info MessageHeaders p) => O.IsLabelProxy t (MessageHeaders -> p) where fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #if MIN_VERSION_base(4,9,0) instance (info ~ ResolveMessageHeadersMethod t MessageHeaders, O.MethodInfo info MessageHeaders p) => O.IsLabel t (MessageHeaders -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif #endif