-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria

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

module GI.Soup.Functions
    ( 

 -- * Methods


-- ** checkVersion #method:checkVersion#

    checkVersion                            ,


-- ** cookiesFromRequest #method:cookiesFromRequest#

    cookiesFromRequest                      ,


-- ** cookiesFromResponse #method:cookiesFromResponse#

    cookiesFromResponse                     ,


-- ** cookiesToCookieHeader #method:cookiesToCookieHeader#

    cookiesToCookieHeader                   ,


-- ** cookiesToRequest #method:cookiesToRequest#

    cookiesToRequest                        ,


-- ** cookiesToResponse #method:cookiesToResponse#

    cookiesToResponse                       ,


-- ** dateTimeNewFromHttpString #method:dateTimeNewFromHttpString#

    dateTimeNewFromHttpString               ,


-- ** dateTimeToString #method:dateTimeToString#

    dateTimeToString                        ,


-- ** formEncodeDatalist #method:formEncodeDatalist#

    formEncodeDatalist                      ,


-- ** formEncodeHash #method:formEncodeHash#

    formEncodeHash                          ,


-- ** getMajorVersion #method:getMajorVersion#

    getMajorVersion                         ,


-- ** getMicroVersion #method:getMicroVersion#

    getMicroVersion                         ,


-- ** getMinorVersion #method:getMinorVersion#

    getMinorVersion                         ,


-- ** headerContains #method:headerContains#

    headerContains                          ,


-- ** headerFreeParamList #method:headerFreeParamList#

    headerFreeParamList                     ,


-- ** headerGStringAppendParam #method:headerGStringAppendParam#

    headerGStringAppendParam                ,


-- ** headerGStringAppendParamQuoted #method:headerGStringAppendParamQuoted#

    headerGStringAppendParamQuoted          ,


-- ** headerParseList #method:headerParseList#

    headerParseList                         ,


-- ** headerParseParamList #method:headerParseParamList#

    headerParseParamList                    ,


-- ** headerParseParamListStrict #method:headerParseParamListStrict#

    headerParseParamListStrict              ,


-- ** headerParseQualityList #method:headerParseQualityList#

    headerParseQualityList                  ,


-- ** headerParseSemiParamList #method:headerParseSemiParamList#

    headerParseSemiParamList                ,


-- ** headerParseSemiParamListStrict #method:headerParseSemiParamListStrict#

    headerParseSemiParamListStrict          ,


-- ** headersParse #method:headersParse#

    headersParse                            ,


-- ** headersParseRequest #method:headersParseRequest#

    headersParseRequest                     ,


-- ** headersParseResponse #method:headersParseResponse#

    headersParseResponse                    ,


-- ** headersParseStatusLine #method:headersParseStatusLine#

    headersParseStatusLine                  ,


-- ** tldDomainIsPublicSuffix #method:tldDomainIsPublicSuffix#

    tldDomainIsPublicSuffix                 ,


-- ** tldGetBaseDomain #method:tldGetBaseDomain#

    tldGetBaseDomain                        ,


-- ** uriDecodeDataUri #method:uriDecodeDataUri#

    uriDecodeDataUri                        ,


-- ** uriEqual #method:uriEqual#

    uriEqual                                ,


-- ** websocketClientPrepareHandshake #method:websocketClientPrepareHandshake#

    websocketClientPrepareHandshake         ,


-- ** websocketClientVerifyHandshake #method:websocketClientVerifyHandshake#

    websocketClientVerifyHandshake          ,


-- ** websocketServerCheckHandshake #method:websocketServerCheckHandshake#

    websocketServerCheckHandshake           ,


-- ** websocketServerProcessHandshake #method:websocketServerProcessHandshake#

    websocketServerProcessHandshake         ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R

import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.Data as GLib.Data
import qualified GI.GLib.Structs.DateTime as GLib.DateTime
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GLib.Structs.Uri as GLib.Uri
import qualified GI.GObject.Structs.TypeClass as GObject.TypeClass
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Objects.Message as Soup.Message
import {-# SOURCE #-} qualified GI.Soup.Objects.ServerMessage as Soup.ServerMessage
import {-# SOURCE #-} qualified GI.Soup.Objects.WebsocketExtension as Soup.WebsocketExtension
import {-# SOURCE #-} qualified GI.Soup.Structs.Cookie as Soup.Cookie
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders

-- function websocket_server_process_handshake
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "#SoupServerMessage containing the client side of a WebSocket handshake"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "expected_origin"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "expected Origin header"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "protocols"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "allowed WebSocket\n  protocols."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "supported_extensions"
--           , argType =
--               TPtrArray
--                 (TInterface Name { namespace = "GObject" , name = "TypeClass" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "list\n  of supported extension types"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "accepted_extensions"
--           , argType =
--               TGList
--                 (TInterface
--                    Name { namespace = "Soup" , name = "WebsocketExtension" })
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a\n  #GList of #SoupWebsocketExtension objects"
--                 , 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_websocket_server_process_handshake" soup_websocket_server_process_handshake :: 
    Ptr Soup.ServerMessage.ServerMessage -> -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    CString ->                              -- expected_origin : TBasicType TUTF8
    Ptr CString ->                          -- protocols : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) -> -- supported_extensions : TPtrArray (TInterface (Name {namespace = "GObject", name = "TypeClass"}))
    Ptr (Ptr (GList (Ptr Soup.WebsocketExtension.WebsocketExtension))) -> -- accepted_extensions : TGList (TInterface (Name {namespace = "Soup", name = "WebsocketExtension"}))
    IO CInt

-- | Examines the method and request headers in /@msg@/ and (assuming /@msg@/
-- contains a valid handshake request), fills in the handshake
-- response.
-- 
-- If /@expectedOrigin@/ is non-'P.Nothing', then only requests containing a matching
-- \"Origin\" header will be accepted. If /@protocols@/ is non-'P.Nothing', then
-- only requests containing a compatible \"Sec-WebSocket-Protocols\"
-- header will be accepted. If /@supportedExtensions@/ is non-'P.Nothing', then
-- only requests containing valid supported extensions in
-- \"Sec-WebSocket-Extensions\" header will be accepted. The accepted extensions
-- will be returned in /@acceptedExtensions@/ parameter if non-'P.Nothing'.
-- 
-- This is a low-level function; if you use
-- [method/@server@/.add_websocket_handler] to handle accepting WebSocket
-- connections, it will call this for you.
websocketServerProcessHandshake ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.ServerMessage.IsServerMessage a) =>
    a
    -- ^ /@msg@/: t'GI.Soup.Objects.ServerMessage.ServerMessage' containing the client side of a WebSocket handshake
    -> Maybe (T.Text)
    -- ^ /@expectedOrigin@/: expected Origin header
    -> Maybe ([T.Text])
    -- ^ /@protocols@/: allowed WebSocket
    --   protocols.
    -> Maybe ([GObject.TypeClass.TypeClass])
    -- ^ /@supportedExtensions@/: list
    --   of supported extension types
    -> m ((Bool, [Soup.WebsocketExtension.WebsocketExtension]))
    -- ^ __Returns:__ 'P.True' if /@msg@/ contained a valid WebSocket handshake
    --   request and was updated to contain a handshake response. 'P.False' if not.
websocketServerProcessHandshake :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a
-> Maybe Text
-> Maybe [Text]
-> Maybe [TypeClass]
-> m (Bool, [WebsocketExtension])
websocketServerProcessHandshake a
msg Maybe Text
expectedOrigin Maybe [Text]
protocols Maybe [TypeClass]
supportedExtensions = IO (Bool, [WebsocketExtension]) -> m (Bool, [WebsocketExtension])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, [WebsocketExtension]) -> m (Bool, [WebsocketExtension]))
-> IO (Bool, [WebsocketExtension])
-> m (Bool, [WebsocketExtension])
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr CChar
maybeExpectedOrigin <- case Maybe Text
expectedOrigin of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jExpectedOrigin -> do
            Ptr CChar
jExpectedOrigin' <- Text -> IO (Ptr CChar)
textToCString Text
jExpectedOrigin
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jExpectedOrigin'
    Ptr (Ptr CChar)
maybeProtocols <- case Maybe [Text]
protocols of
        Maybe [Text]
Nothing -> Ptr (Ptr CChar) -> IO (Ptr (Ptr CChar))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
forall a. Ptr a
nullPtr
        Just [Text]
jProtocols -> do
            Ptr (Ptr CChar)
jProtocols' <- [Text] -> IO (Ptr (Ptr CChar))
packZeroTerminatedUTF8CArray [Text]
jProtocols
            Ptr (Ptr CChar) -> IO (Ptr (Ptr CChar))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
jProtocols'
    Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions <- case Maybe [TypeClass]
supportedExtensions of
        Maybe [TypeClass]
Nothing -> Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
forall a. Ptr a
nullPtr
        Just [TypeClass]
jSupportedExtensions -> do
            [Ptr TypeClass]
jSupportedExtensions' <- (TypeClass -> IO (Ptr TypeClass))
-> [TypeClass] -> IO [Ptr TypeClass]
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 TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [TypeClass]
jSupportedExtensions
            Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions'' <- [Ptr TypeClass] -> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr TypeClass]
jSupportedExtensions'
            Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions''
    Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions <- IO (Ptr (Ptr (GList (Ptr WebsocketExtension))))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GList (Ptr Soup.WebsocketExtension.WebsocketExtension))))
    CInt
result <- Ptr ServerMessage
-> Ptr CChar
-> Ptr (Ptr CChar)
-> Ptr (GPtrArray (Ptr TypeClass))
-> Ptr (Ptr (GList (Ptr WebsocketExtension)))
-> IO CInt
soup_websocket_server_process_handshake Ptr ServerMessage
msg' Ptr CChar
maybeExpectedOrigin Ptr (Ptr CChar)
maybeProtocols Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Ptr (GList (Ptr WebsocketExtension))
acceptedExtensions' <- Ptr (Ptr (GList (Ptr WebsocketExtension)))
-> IO (Ptr (GList (Ptr WebsocketExtension)))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions
    [Ptr WebsocketExtension]
acceptedExtensions'' <- Ptr (GList (Ptr WebsocketExtension)) -> IO [Ptr WebsocketExtension]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr WebsocketExtension))
acceptedExtensions'
    [WebsocketExtension]
acceptedExtensions''' <- (Ptr WebsocketExtension -> IO WebsocketExtension)
-> [Ptr WebsocketExtension] -> IO [WebsocketExtension]
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 WebsocketExtension -> WebsocketExtension)
-> Ptr WebsocketExtension -> IO WebsocketExtension
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr WebsocketExtension -> WebsocketExtension
Soup.WebsocketExtension.WebsocketExtension) [Ptr WebsocketExtension]
acceptedExtensions''
    Ptr (GList (Ptr WebsocketExtension)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr WebsocketExtension))
acceptedExtensions'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe [TypeClass] -> ([TypeClass] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [TypeClass]
supportedExtensions ((TypeClass -> IO ()) -> [TypeClass] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeExpectedOrigin
    (Ptr CChar -> IO ()) -> Ptr (Ptr CChar) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeProtocols
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeProtocols
    Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
    Ptr (Ptr (GList (Ptr WebsocketExtension))) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions
    (Bool, [WebsocketExtension]) -> IO (Bool, [WebsocketExtension])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', [WebsocketExtension]
acceptedExtensions''')


-- function websocket_server_check_handshake
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "#SoupServerMessage containing the client side of a WebSocket handshake"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "origin"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "expected Origin header"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "protocols"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "allowed WebSocket\n  protocols."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "supported_extensions"
--           , argType =
--               TPtrArray
--                 (TInterface Name { namespace = "GObject" , name = "TypeClass" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "list\n  of supported extension types"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "soup_websocket_server_check_handshake" soup_websocket_server_check_handshake :: 
    Ptr Soup.ServerMessage.ServerMessage -> -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    CString ->                              -- origin : TBasicType TUTF8
    Ptr CString ->                          -- protocols : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) -> -- supported_extensions : TPtrArray (TInterface (Name {namespace = "GObject", name = "TypeClass"}))
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Examines the method and request headers in /@msg@/ and determines
-- whether /@msg@/ contains a valid handshake request.
-- 
-- If /@origin@/ is non-'P.Nothing', then only requests containing a matching
-- \"Origin\" header will be accepted. If /@protocols@/ is non-'P.Nothing', then
-- only requests containing a compatible \"Sec-WebSocket-Protocols\"
-- header will be accepted. If /@supportedExtensions@/ is non-'P.Nothing', then
-- only requests containing valid supported extensions in
-- \"Sec-WebSocket-Extensions\" header will be accepted.
-- 
-- Normally [func/@websocketServerProcessHandshake@/]
-- will take care of this for you, and if you use
-- [method/@server@/.add_websocket_handler] to handle accepting WebSocket
-- connections, it will call that for you. However, this function may
-- be useful if you need to perform more complicated validation; eg,
-- accepting multiple different Origins, or handling different protocols
-- depending on the path.
websocketServerCheckHandshake ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.ServerMessage.IsServerMessage a) =>
    a
    -- ^ /@msg@/: t'GI.Soup.Objects.ServerMessage.ServerMessage' containing the client side of a WebSocket handshake
    -> Maybe (T.Text)
    -- ^ /@origin@/: expected Origin header
    -> Maybe ([T.Text])
    -- ^ /@protocols@/: allowed WebSocket
    --   protocols.
    -> Maybe ([GObject.TypeClass.TypeClass])
    -- ^ /@supportedExtensions@/: list
    --   of supported extension types
    -> m ()
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
websocketServerCheckHandshake :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> Maybe Text -> Maybe [Text] -> Maybe [TypeClass] -> m ()
websocketServerCheckHandshake a
msg Maybe Text
origin Maybe [Text]
protocols Maybe [TypeClass]
supportedExtensions = 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 ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr CChar
maybeOrigin <- case Maybe Text
origin of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jOrigin -> do
            Ptr CChar
jOrigin' <- Text -> IO (Ptr CChar)
textToCString Text
jOrigin
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jOrigin'
    Ptr (Ptr CChar)
maybeProtocols <- case Maybe [Text]
protocols of
        Maybe [Text]
Nothing -> Ptr (Ptr CChar) -> IO (Ptr (Ptr CChar))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
forall a. Ptr a
nullPtr
        Just [Text]
jProtocols -> do
            Ptr (Ptr CChar)
jProtocols' <- [Text] -> IO (Ptr (Ptr CChar))
packZeroTerminatedUTF8CArray [Text]
jProtocols
            Ptr (Ptr CChar) -> IO (Ptr (Ptr CChar))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
jProtocols'
    Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions <- case Maybe [TypeClass]
supportedExtensions of
        Maybe [TypeClass]
Nothing -> Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
forall a. Ptr a
nullPtr
        Just [TypeClass]
jSupportedExtensions -> do
            [Ptr TypeClass]
jSupportedExtensions' <- (TypeClass -> IO (Ptr TypeClass))
-> [TypeClass] -> IO [Ptr TypeClass]
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 TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [TypeClass]
jSupportedExtensions
            Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions'' <- [Ptr TypeClass] -> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr TypeClass]
jSupportedExtensions'
            Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions''
    IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr ServerMessage
-> Ptr CChar
-> Ptr (Ptr CChar)
-> Ptr (GPtrArray (Ptr TypeClass))
-> Ptr (Ptr GError)
-> IO CInt
soup_websocket_server_check_handshake Ptr ServerMessage
msg' Ptr CChar
maybeOrigin Ptr (Ptr CChar)
maybeProtocols Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
        Maybe [TypeClass] -> ([TypeClass] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [TypeClass]
supportedExtensions ((TypeClass -> IO ()) -> [TypeClass] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
        Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeOrigin
        (Ptr CChar -> IO ()) -> Ptr (Ptr CChar) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeProtocols
        Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeProtocols
        Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
        () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
     ) (do
        Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeOrigin
        (Ptr CChar -> IO ()) -> Ptr (Ptr CChar) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeProtocols
        Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeProtocols
        Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
     )


-- function websocket_client_verify_handshake
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "#SoupMessage containing both client and server sides of a\n  WebSocket handshake"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "supported_extensions"
--           , argType =
--               TPtrArray
--                 (TInterface Name { namespace = "GObject" , name = "TypeClass" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "list\n  of supported extension types"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "accepted_extensions"
--           , argType =
--               TGList
--                 (TInterface
--                    Name { namespace = "Soup" , name = "WebsocketExtension" })
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a\n  #GList of #SoupWebsocketExtension objects"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False

foreign import ccall "soup_websocket_client_verify_handshake" soup_websocket_client_verify_handshake :: 
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) -> -- supported_extensions : TPtrArray (TInterface (Name {namespace = "GObject", name = "TypeClass"}))
    Ptr (Ptr (GList (Ptr Soup.WebsocketExtension.WebsocketExtension))) -> -- accepted_extensions : TGList (TInterface (Name {namespace = "Soup", name = "WebsocketExtension"}))
    Ptr (Ptr GError) ->                     -- error
    IO CInt

-- | Looks at the response status code and headers in /@msg@/ and
-- determines if they contain a valid WebSocket handshake response
-- (given the handshake request in /@msg@/\'s request headers).
-- 
-- If /@supportedExtensions@/ is non-'P.Nothing', extensions included in the
-- response \"Sec-WebSocket-Extensions\" are verified too. Accepted
-- extensions are returned in /@acceptedExtensions@/ parameter if non-'P.Nothing'.
-- 
-- This is a low-level function; if you use
-- [method/@session@/.websocket_connect_async] to create a WebSocket
-- connection, it will call this for you.
websocketClientVerifyHandshake ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
    a
    -- ^ /@msg@/: t'GI.Soup.Objects.Message.Message' containing both client and server sides of a
    --   WebSocket handshake
    -> Maybe ([GObject.TypeClass.TypeClass])
    -- ^ /@supportedExtensions@/: list
    --   of supported extension types
    -> m ([Soup.WebsocketExtension.WebsocketExtension])
    -- ^ /(Can throw 'Data.GI.Base.GError.GError')/
websocketClientVerifyHandshake :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Maybe [TypeClass] -> m [WebsocketExtension]
websocketClientVerifyHandshake a
msg Maybe [TypeClass]
supportedExtensions = IO [WebsocketExtension] -> m [WebsocketExtension]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [WebsocketExtension] -> m [WebsocketExtension])
-> IO [WebsocketExtension] -> m [WebsocketExtension]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions <- case Maybe [TypeClass]
supportedExtensions of
        Maybe [TypeClass]
Nothing -> Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
forall a. Ptr a
nullPtr
        Just [TypeClass]
jSupportedExtensions -> do
            [Ptr TypeClass]
jSupportedExtensions' <- (TypeClass -> IO (Ptr TypeClass))
-> [TypeClass] -> IO [Ptr TypeClass]
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 TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [TypeClass]
jSupportedExtensions
            Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions'' <- [Ptr TypeClass] -> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr TypeClass]
jSupportedExtensions'
            Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions''
    Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions <- IO (Ptr (Ptr (GList (Ptr WebsocketExtension))))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GList (Ptr Soup.WebsocketExtension.WebsocketExtension))))
    IO [WebsocketExtension] -> IO () -> IO [WebsocketExtension]
forall a b. IO a -> IO b -> IO a
onException (do
        CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr Message
-> Ptr (GPtrArray (Ptr TypeClass))
-> Ptr (Ptr (GList (Ptr WebsocketExtension)))
-> Ptr (Ptr GError)
-> IO CInt
soup_websocket_client_verify_handshake Ptr Message
msg' Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions
        Ptr (GList (Ptr WebsocketExtension))
acceptedExtensions' <- Ptr (Ptr (GList (Ptr WebsocketExtension)))
-> IO (Ptr (GList (Ptr WebsocketExtension)))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions
        [Ptr WebsocketExtension]
acceptedExtensions'' <- Ptr (GList (Ptr WebsocketExtension)) -> IO [Ptr WebsocketExtension]
forall a. Ptr (GList (Ptr a)) -> IO [Ptr a]
unpackGList Ptr (GList (Ptr WebsocketExtension))
acceptedExtensions'
        [WebsocketExtension]
acceptedExtensions''' <- (Ptr WebsocketExtension -> IO WebsocketExtension)
-> [Ptr WebsocketExtension] -> IO [WebsocketExtension]
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 WebsocketExtension -> WebsocketExtension)
-> Ptr WebsocketExtension -> IO WebsocketExtension
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr WebsocketExtension -> WebsocketExtension
Soup.WebsocketExtension.WebsocketExtension) [Ptr WebsocketExtension]
acceptedExtensions''
        Ptr (GList (Ptr WebsocketExtension)) -> IO ()
forall a. Ptr (GList a) -> IO ()
g_list_free Ptr (GList (Ptr WebsocketExtension))
acceptedExtensions'
        a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
        Maybe [TypeClass] -> ([TypeClass] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [TypeClass]
supportedExtensions ((TypeClass -> IO ()) -> [TypeClass] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
        Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
        Ptr (Ptr (GList (Ptr WebsocketExtension))) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions
        [WebsocketExtension] -> IO [WebsocketExtension]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [WebsocketExtension]
acceptedExtensions'''
     ) (do
        Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
        Ptr (Ptr (GList (Ptr WebsocketExtension))) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GList (Ptr WebsocketExtension)))
acceptedExtensions
     )


-- function websocket_client_prepare_handshake
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "origin"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the \"Origin\" header to set"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "protocols"
--           , argType = TCArray True (-1) (-1) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "list of\n  protocols to offer"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "supported_extensions"
--           , argType =
--               TPtrArray
--                 (TInterface Name { namespace = "GObject" , name = "TypeClass" })
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "list\n  of supported extension types"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_websocket_client_prepare_handshake" soup_websocket_client_prepare_handshake :: 
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    CString ->                              -- origin : TBasicType TUTF8
    Ptr CString ->                          -- protocols : TCArray True (-1) (-1) (TBasicType TUTF8)
    Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) -> -- supported_extensions : TPtrArray (TInterface (Name {namespace = "GObject", name = "TypeClass"}))
    IO ()

-- | Adds the necessary headers to /@msg@/ to request a WebSocket
-- handshake including supported WebSocket extensions.
-- 
-- The message body and non-WebSocket-related headers are
-- not modified.
-- 
-- This is a low-level function; if you use
-- [method/@session@/.websocket_connect_async] to create a WebSocket connection, it
-- will call this for you.
websocketClientPrepareHandshake ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> Maybe (T.Text)
    -- ^ /@origin@/: the \"Origin\" header to set
    -> Maybe ([T.Text])
    -- ^ /@protocols@/: list of
    --   protocols to offer
    -> Maybe ([GObject.TypeClass.TypeClass])
    -- ^ /@supportedExtensions@/: list
    --   of supported extension types
    -> m ()
websocketClientPrepareHandshake :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> Maybe Text -> Maybe [Text] -> Maybe [TypeClass] -> m ()
websocketClientPrepareHandshake a
msg Maybe Text
origin Maybe [Text]
protocols Maybe [TypeClass]
supportedExtensions = 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 Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr CChar
maybeOrigin <- case Maybe Text
origin of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jOrigin -> do
            Ptr CChar
jOrigin' <- Text -> IO (Ptr CChar)
textToCString Text
jOrigin
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jOrigin'
    Ptr (Ptr CChar)
maybeProtocols <- case Maybe [Text]
protocols of
        Maybe [Text]
Nothing -> Ptr (Ptr CChar) -> IO (Ptr (Ptr CChar))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
forall a. Ptr a
nullPtr
        Just [Text]
jProtocols -> do
            Ptr (Ptr CChar)
jProtocols' <- [Text] -> IO (Ptr (Ptr CChar))
packZeroTerminatedUTF8CArray [Text]
jProtocols
            Ptr (Ptr CChar) -> IO (Ptr (Ptr CChar))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (Ptr CChar)
jProtocols'
    Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions <- case Maybe [TypeClass]
supportedExtensions of
        Maybe [TypeClass]
Nothing -> Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
forall a. Ptr a
nullPtr
        Just [TypeClass]
jSupportedExtensions -> do
            [Ptr TypeClass]
jSupportedExtensions' <- (TypeClass -> IO (Ptr TypeClass))
-> [TypeClass] -> IO [Ptr TypeClass]
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 TypeClass -> IO (Ptr TypeClass)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [TypeClass]
jSupportedExtensions
            Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions'' <- [Ptr TypeClass] -> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. [Ptr a] -> IO (Ptr (GPtrArray (Ptr a)))
packGPtrArray [Ptr TypeClass]
jSupportedExtensions'
            Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions''
    Ptr Message
-> Ptr CChar
-> Ptr (Ptr CChar)
-> Ptr (GPtrArray (Ptr TypeClass))
-> IO ()
soup_websocket_client_prepare_handshake Ptr Message
msg' Ptr CChar
maybeOrigin Ptr (Ptr CChar)
maybeProtocols Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe [TypeClass] -> ([TypeClass] -> IO ()) -> IO ()
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe [TypeClass]
supportedExtensions ((TypeClass -> IO ()) -> [TypeClass] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ TypeClass -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr)
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeOrigin
    (Ptr CChar -> IO ()) -> Ptr (Ptr CChar) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeProtocols
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
maybeProtocols
    Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- function uri_equal
-- Args: [ Arg
--           { argCName = "uri1"
--           , argType = TInterface Name { namespace = "GLib" , name = "Uri" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GUri" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "uri2"
--           , argType = TInterface Name { namespace = "GLib" , name = "Uri" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "another #GUri" , 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_uri_equal" soup_uri_equal :: 
    Ptr GLib.Uri.Uri ->                     -- uri1 : TInterface (Name {namespace = "GLib", name = "Uri"})
    Ptr GLib.Uri.Uri ->                     -- uri2 : TInterface (Name {namespace = "GLib", name = "Uri"})
    IO CInt

-- | Tests whether or not /@uri1@/ and /@uri2@/ are equal in all parts.
uriEqual ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.Uri.Uri
    -- ^ /@uri1@/: a t'GI.GLib.Structs.Uri.Uri'
    -> GLib.Uri.Uri
    -- ^ /@uri2@/: another t'GI.GLib.Structs.Uri.Uri'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if equal otherwise 'P.False'
uriEqual :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Uri -> Uri -> m Bool
uriEqual Uri
uri1 Uri
uri2 = 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 Uri
uri1' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri1
    Ptr Uri
uri2' <- Uri -> IO (Ptr Uri)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Uri
uri2
    CInt
result <- Ptr Uri -> Ptr Uri -> IO CInt
soup_uri_equal Ptr Uri
uri1' Ptr Uri
uri2'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri1
    Uri -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Uri
uri2
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'


-- function uri_decode_data_uri
-- Args: [ Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a data URI, in string form"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_type"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "location to store content type"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "Bytes" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_uri_decode_data_uri" soup_uri_decode_data_uri :: 
    CString ->                              -- uri : TBasicType TUTF8
    Ptr CString ->                          -- content_type : TBasicType TUTF8
    IO (Ptr GLib.Bytes.Bytes)

-- | Decodes the given data URI and returns its contents and /@contentType@/.
uriDecodeDataUri ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@uri@/: a data URI, in string form
    -> m ((GLib.Bytes.Bytes, Maybe T.Text))
    -- ^ __Returns:__ a t'GI.GLib.Structs.Bytes.Bytes' with the contents of /@uri@/,
    --    or 'P.Nothing' if /@uri@/ is not a valid data URI
uriDecodeDataUri :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Bytes, Maybe Text)
uriDecodeDataUri Text
uri = IO (Bytes, Maybe Text) -> m (Bytes, Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bytes, Maybe Text) -> m (Bytes, Maybe Text))
-> IO (Bytes, Maybe Text) -> m (Bytes, Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
uri' <- Text -> IO (Ptr CChar)
textToCString Text
uri
    Ptr (Ptr CChar)
contentType <- IO (Ptr (Ptr CChar))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr Bytes
result <- Ptr CChar -> Ptr (Ptr CChar) -> IO (Ptr Bytes)
soup_uri_decode_data_uri Ptr CChar
uri' Ptr (Ptr CChar)
contentType
    Text -> Ptr Bytes -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"uriDecodeDataUri" Ptr Bytes
result
    Bytes
result' <- ((ManagedPtr Bytes -> Bytes) -> Ptr Bytes -> IO Bytes
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
    Ptr CChar
contentType' <- Ptr (Ptr CChar) -> IO (Ptr CChar)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CChar)
contentType
    Maybe Text
maybeContentType' <- Ptr CChar -> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr CChar
contentType' ((Ptr CChar -> IO Text) -> IO (Maybe Text))
-> (Ptr CChar -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \Ptr CChar
contentType'' -> do
        Text
contentType''' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
contentType''
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
contentType'''
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
contentType'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
uri'
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
contentType
    (Bytes, Maybe Text) -> IO (Bytes, Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bytes
result', Maybe Text
maybeContentType')


-- function tld_get_base_domain
-- Args: [ Arg
--           { argCName = "hostname"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a hostname" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : True
-- Skip return : False

foreign import ccall "soup_tld_get_base_domain" soup_tld_get_base_domain :: 
    CString ->                              -- hostname : TBasicType TUTF8
    Ptr (Ptr GError) ->                     -- error
    IO CString

-- | Finds the base domain for a given /@hostname@/
-- 
-- The base domain is composed by the top level domain (such as .org, .com,
-- .co.uk, etc) plus the second level domain, for example for
-- myhost.mydomain.com it will return mydomain.com.
-- 
-- Note that 'P.Nothing' will be returned for private URLs (those not ending
-- with any well known TLD) because choosing a base domain for them
-- would be totally arbitrary.
-- 
-- Prior to libsoup 2.46, this function required that /@hostname@/ be in
-- UTF-8 if it was an IDN. From 2.46 on, the name can be in either
-- UTF-8 or ASCII format (and the return value will be in the same
-- format).
tldGetBaseDomain ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@hostname@/: a hostname
    -> m T.Text
    -- ^ __Returns:__ a pointer to the start of the base domain in /@hostname@/. If
    --   an error occurs, 'P.Nothing' will be returned and /@error@/ set. /(Can throw 'Data.GI.Base.GError.GError')/
tldGetBaseDomain :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Text
tldGetBaseDomain Text
hostname = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
hostname' <- Text -> IO (Ptr CChar)
textToCString Text
hostname
    IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
        Ptr CChar
result <- (Ptr (Ptr GError) -> IO (Ptr CChar)) -> IO (Ptr CChar)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr CChar)) -> IO (Ptr CChar))
-> (Ptr (Ptr GError) -> IO (Ptr CChar)) -> IO (Ptr CChar)
forall a b. (a -> b) -> a -> b
$ Ptr CChar -> Ptr (Ptr GError) -> IO (Ptr CChar)
soup_tld_get_base_domain Ptr CChar
hostname'
        Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tldGetBaseDomain" Ptr CChar
result
        Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
        Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
hostname'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
     ) (do
        Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
hostname'
     )


-- function tld_domain_is_public_suffix
-- Args: [ Arg
--           { argCName = "domain"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a domain name" , 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_tld_domain_is_public_suffix" soup_tld_domain_is_public_suffix :: 
    CString ->                              -- domain : TBasicType TUTF8
    IO CInt

-- | Looks whether the /@domain@/ passed as argument is a public domain
-- suffix (.org, .com, .co.uk, etc) or not.
-- 
-- Prior to libsoup 2.46, this function required that /@domain@/ be in
-- UTF-8 if it was an IDN. From 2.46 on, the name can be in either
-- UTF-8 or ASCII format.
tldDomainIsPublicSuffix ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@domain@/: a domain name
    -> m Bool
    -- ^ __Returns:__ 'P.True' if it is a public domain, 'P.False' otherwise.
tldDomainIsPublicSuffix :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m Bool
tldDomainIsPublicSuffix Text
domain = 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 CChar
domain' <- Text -> IO (Ptr CChar)
textToCString Text
domain
    CInt
result <- Ptr CChar -> IO CInt
soup_tld_domain_is_public_suffix Ptr CChar
domain'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
domain'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'


-- function headers_parse_status_line
-- Args: [ Arg
--           { argCName = "status_line"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an HTTP Status-Line"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ver"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HTTPVersion" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with the HTTP\n  version"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "status_code"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with\n  the status code"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "reason_phrase"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with\n  the reason phrase"
--                 , 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_headers_parse_status_line" soup_headers_parse_status_line :: 
    CString ->                              -- status_line : TBasicType TUTF8
    Ptr CUInt ->                            -- ver : TInterface (Name {namespace = "Soup", name = "HTTPVersion"})
    Ptr Word32 ->                           -- status_code : TBasicType TUInt
    Ptr CString ->                          -- reason_phrase : TBasicType TUTF8
    IO CInt

-- | Parses the HTTP Status-Line string in /@statusLine@/ into /@ver@/,
-- /@statusCode@/, and /@reasonPhrase@/.
-- 
-- /@statusLine@/ must be terminated by either \"\\0\" or \"\\r\\n\".
headersParseStatusLine ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@statusLine@/: an HTTP Status-Line
    -> m ((Bool, Soup.Enums.HTTPVersion, Word32, T.Text))
    -- ^ __Returns:__ 'P.True' if /@statusLine@/ was parsed successfully.
headersParseStatusLine :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Bool, HTTPVersion, Word32, Text)
headersParseStatusLine Text
statusLine = IO (Bool, HTTPVersion, Word32, Text)
-> m (Bool, HTTPVersion, Word32, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, HTTPVersion, Word32, Text)
 -> m (Bool, HTTPVersion, Word32, Text))
-> IO (Bool, HTTPVersion, Word32, Text)
-> m (Bool, HTTPVersion, Word32, Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
statusLine' <- Text -> IO (Ptr CChar)
textToCString Text
statusLine
    Ptr CUInt
ver <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    Ptr Word32
statusCode <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr (Ptr CChar)
reasonPhrase <- IO (Ptr (Ptr CChar))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    CInt
result <- Ptr CChar -> Ptr CUInt -> Ptr Word32 -> Ptr (Ptr CChar) -> IO CInt
soup_headers_parse_status_line Ptr CChar
statusLine' Ptr CUInt
ver Ptr Word32
statusCode Ptr (Ptr CChar)
reasonPhrase
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CUInt
ver' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
ver
    let ver'' :: HTTPVersion
ver'' = (Int -> HTTPVersion
forall a. Enum a => Int -> a
toEnum (Int -> HTTPVersion) -> (CUInt -> Int) -> CUInt -> HTTPVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
ver'
    Word32
statusCode' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
statusCode
    Ptr CChar
reasonPhrase' <- Ptr (Ptr CChar) -> IO (Ptr CChar)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CChar)
reasonPhrase
    Text
reasonPhrase'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
reasonPhrase'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
reasonPhrase'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
statusLine'
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
ver
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
statusCode
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
reasonPhrase
    (Bool, HTTPVersion, Word32, Text)
-> IO (Bool, HTTPVersion, Word32, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', HTTPVersion
ver'', Word32
statusCode', Text
reasonPhrase'')


-- function headers_parse_response
-- Args: [ Arg
--           { argCName = "str"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the headers (up to, but not including, the trailing blank line)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "length of @str" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "headers"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "#SoupMessageHeaders to store the header values in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "ver"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HTTPVersion" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with the HTTP\n  version"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "status_code"
--           , argType = TBasicType TUInt
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with\n  the status code"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "reason_phrase"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with\n  the reason phrase"
--                 , 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_headers_parse_response" soup_headers_parse_response :: 
    CString ->                              -- str : TBasicType TUTF8
    Int32 ->                                -- len : TBasicType TInt
    Ptr Soup.MessageHeaders.MessageHeaders -> -- headers : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr CUInt ->                            -- ver : TInterface (Name {namespace = "Soup", name = "HTTPVersion"})
    Ptr Word32 ->                           -- status_code : TBasicType TUInt
    Ptr CString ->                          -- reason_phrase : TBasicType TUTF8
    IO CInt

-- | Parses the headers of an HTTP response in /@str@/ and stores the
-- results in /@ver@/, /@statusCode@/, /@reasonPhrase@/, and /@headers@/.
-- 
-- Beware that /@headers@/ may be modified even on failure.
headersParseResponse ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@str@/: the headers (up to, but not including, the trailing blank line)
    -> Int32
    -- ^ /@len@/: length of /@str@/
    -> Soup.MessageHeaders.MessageHeaders
    -- ^ /@headers@/: t'GI.Soup.Structs.MessageHeaders.MessageHeaders' to store the header values in
    -> m ((Bool, Soup.Enums.HTTPVersion, Word32, T.Text))
    -- ^ __Returns:__ success or failure.
headersParseResponse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text
-> Int32 -> MessageHeaders -> m (Bool, HTTPVersion, Word32, Text)
headersParseResponse Text
str Int32
len MessageHeaders
headers = IO (Bool, HTTPVersion, Word32, Text)
-> m (Bool, HTTPVersion, Word32, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, HTTPVersion, Word32, Text)
 -> m (Bool, HTTPVersion, Word32, Text))
-> IO (Bool, HTTPVersion, Word32, Text)
-> m (Bool, HTTPVersion, Word32, Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
str' <- Text -> IO (Ptr CChar)
textToCString Text
str
    Ptr MessageHeaders
headers' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
headers
    Ptr CUInt
ver <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    Ptr Word32
statusCode <- IO (Ptr Word32)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
    Ptr (Ptr CChar)
reasonPhrase <- IO (Ptr (Ptr CChar))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    CInt
result <- Ptr CChar
-> Int32
-> Ptr MessageHeaders
-> Ptr CUInt
-> Ptr Word32
-> Ptr (Ptr CChar)
-> IO CInt
soup_headers_parse_response Ptr CChar
str' Int32
len Ptr MessageHeaders
headers' Ptr CUInt
ver Ptr Word32
statusCode Ptr (Ptr CChar)
reasonPhrase
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    CUInt
ver' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
ver
    let ver'' :: HTTPVersion
ver'' = (Int -> HTTPVersion
forall a. Enum a => Int -> a
toEnum (Int -> HTTPVersion) -> (CUInt -> Int) -> CUInt -> HTTPVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
ver'
    Word32
statusCode' <- Ptr Word32 -> IO Word32
forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
statusCode
    Ptr CChar
reasonPhrase' <- Ptr (Ptr CChar) -> IO (Ptr CChar)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CChar)
reasonPhrase
    Text
reasonPhrase'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
reasonPhrase'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
reasonPhrase'
    MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
headers
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
str'
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
ver
    Ptr Word32 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word32
statusCode
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
reasonPhrase
    (Bool, HTTPVersion, Word32, Text)
-> IO (Bool, HTTPVersion, Word32, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', HTTPVersion
ver'', Word32
statusCode', Text
reasonPhrase'')


-- function headers_parse_request
-- Args: [ Arg
--           { argCName = "str"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the headers (up to, but not including, the trailing blank line)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "length of @str" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "req_headers"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "#SoupMessageHeaders to store the header values in"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "req_method"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with the\n  request method"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "req_path"
--           , argType = TBasicType TUTF8
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with the\n  request path"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       , Arg
--           { argCName = "ver"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HTTPVersion" }
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "if non-%NULL, will be filled in with the HTTP\n  version"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_headers_parse_request" soup_headers_parse_request :: 
    CString ->                              -- str : TBasicType TUTF8
    Int32 ->                                -- len : TBasicType TInt
    Ptr Soup.MessageHeaders.MessageHeaders -> -- req_headers : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    Ptr CString ->                          -- req_method : TBasicType TUTF8
    Ptr CString ->                          -- req_path : TBasicType TUTF8
    Ptr CUInt ->                            -- ver : TInterface (Name {namespace = "Soup", name = "HTTPVersion"})
    IO Word32

-- | Parses the headers of an HTTP request in /@str@/ and stores the
-- results in /@reqMethod@/, /@reqPath@/, /@ver@/, and /@reqHeaders@/.
-- 
-- Beware that /@reqHeaders@/ may be modified even on failure.
headersParseRequest ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@str@/: the headers (up to, but not including, the trailing blank line)
    -> Int32
    -- ^ /@len@/: length of /@str@/
    -> Soup.MessageHeaders.MessageHeaders
    -- ^ /@reqHeaders@/: t'GI.Soup.Structs.MessageHeaders.MessageHeaders' to store the header values in
    -> m ((Word32, T.Text, T.Text, Soup.Enums.HTTPVersion))
    -- ^ __Returns:__ 'GI.Soup.Enums.StatusOk' if the headers could be parsed, or an
    --   HTTP error to be returned to the client if they could not be.
headersParseRequest :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text
-> Int32 -> MessageHeaders -> m (Word32, Text, Text, HTTPVersion)
headersParseRequest Text
str Int32
len MessageHeaders
reqHeaders = IO (Word32, Text, Text, HTTPVersion)
-> m (Word32, Text, Text, HTTPVersion)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Word32, Text, Text, HTTPVersion)
 -> m (Word32, Text, Text, HTTPVersion))
-> IO (Word32, Text, Text, HTTPVersion)
-> m (Word32, Text, Text, HTTPVersion)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
str' <- Text -> IO (Ptr CChar)
textToCString Text
str
    Ptr MessageHeaders
reqHeaders' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
reqHeaders
    Ptr (Ptr CChar)
reqMethod <- IO (Ptr (Ptr CChar))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr (Ptr CChar)
reqPath <- IO (Ptr (Ptr CChar))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
    Ptr CUInt
ver <- IO (Ptr CUInt)
forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr CUInt)
    Word32
result <- Ptr CChar
-> Int32
-> Ptr MessageHeaders
-> Ptr (Ptr CChar)
-> Ptr (Ptr CChar)
-> Ptr CUInt
-> IO Word32
soup_headers_parse_request Ptr CChar
str' Int32
len Ptr MessageHeaders
reqHeaders' Ptr (Ptr CChar)
reqMethod Ptr (Ptr CChar)
reqPath Ptr CUInt
ver
    Ptr CChar
reqMethod' <- Ptr (Ptr CChar) -> IO (Ptr CChar)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CChar)
reqMethod
    Text
reqMethod'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
reqMethod'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
reqMethod'
    Ptr CChar
reqPath' <- Ptr (Ptr CChar) -> IO (Ptr CChar)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr CChar)
reqPath
    Text
reqPath'' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
reqPath'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
reqPath'
    CUInt
ver' <- Ptr CUInt -> IO CUInt
forall a. Storable a => Ptr a -> IO a
peek Ptr CUInt
ver
    let ver'' :: HTTPVersion
ver'' = (Int -> HTTPVersion
forall a. Enum a => Int -> a
toEnum (Int -> HTTPVersion) -> (CUInt -> Int) -> CUInt -> HTTPVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
ver'
    MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
reqHeaders
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
str'
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
reqMethod
    Ptr (Ptr CChar) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr CChar)
reqPath
    Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
ver
    (Word32, Text, Text, HTTPVersion)
-> IO (Word32, Text, Text, HTTPVersion)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Word32
result, Text
reqMethod'', Text
reqPath'', HTTPVersion
ver'')


-- function headers_parse
-- Args: [ Arg
--           { argCName = "str"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "the header string (including the Request-Line or Status-Line,\n  but not the trailing blank line)"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "len"
--           , argType = TBasicType TInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "length of @str" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "dest"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MessageHeaders" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "#SoupMessageHeaders to store the header values in"
--                 , 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_headers_parse" soup_headers_parse :: 
    CString ->                              -- str : TBasicType TUTF8
    Int32 ->                                -- len : TBasicType TInt
    Ptr Soup.MessageHeaders.MessageHeaders -> -- dest : TInterface (Name {namespace = "Soup", name = "MessageHeaders"})
    IO CInt

-- | Parses the headers of an HTTP request or response in /@str@/ and
-- stores the results in /@dest@/.
-- 
-- Beware that /@dest@/ may be modified even on failure.
-- 
-- This is a low-level method; normally you would use
-- [func/@headersParseRequest@/] or [func/@headersParseResponse@/].
headersParse ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@str@/: the header string (including the Request-Line or Status-Line,
    --   but not the trailing blank line)
    -> Int32
    -- ^ /@len@/: length of /@str@/
    -> Soup.MessageHeaders.MessageHeaders
    -- ^ /@dest@/: t'GI.Soup.Structs.MessageHeaders.MessageHeaders' to store the header values in
    -> m Bool
    -- ^ __Returns:__ success or failure
headersParse :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Int32 -> MessageHeaders -> m Bool
headersParse Text
str Int32
len MessageHeaders
dest = 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 CChar
str' <- Text -> IO (Ptr CChar)
textToCString Text
str
    Ptr MessageHeaders
dest' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
dest
    CInt
result <- Ptr CChar -> Int32 -> Ptr MessageHeaders -> IO CInt
soup_headers_parse Ptr CChar
str' Int32
len Ptr MessageHeaders
dest'
    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
dest
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
str'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'


-- function header_parse_semi_param_list_strict
-- Args: [ Arg
--           { argCName = "header"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a header value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TGHash (TBasicType TUTF8) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "soup_header_parse_semi_param_list_strict" soup_header_parse_semi_param_list_strict :: 
    CString ->                              -- header : TBasicType TUTF8
    IO (Ptr (GHashTable CString CString))

-- | A strict version of [func/@headerParseSemiParamList@/]
-- that bails out if there are duplicate parameters.
-- 
-- Note that this function will treat RFC5987-encoded
-- parameters as duplicated if an ASCII version is also
-- present. For header fields that might contain
-- RFC5987-encoded parameters, use
-- [func/@headerParseSemiParamList@/] instead.
headerParseSemiParamListStrict ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@header@/: a header value
    -> m (Maybe (Map.Map T.Text T.Text))
    -- ^ __Returns:__ 
    --   a t'GI.GLib.Structs.HashTable.HashTable' of list elements, which can be freed with
    --   [func/@headerFreeParamList@/] or 'P.Nothing' if there are duplicate
    --   elements.
headerParseSemiParamListStrict :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe (Map Text Text))
headerParseSemiParamListStrict Text
header = IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text)))
-> IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
header' <- Text -> IO (Ptr CChar)
textToCString Text
header
    Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result <- Ptr CChar -> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
soup_header_parse_semi_param_list_strict Ptr CChar
header'
    Maybe (Map Text Text)
maybeResult <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> (Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result ((Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
 -> IO (Maybe (Map Text Text)))
-> (Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ \Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result' -> do
        [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result'' <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> IO [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result'
        let result''' :: [(Ptr CChar, PtrWrapped (Ptr CChar))]
result''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr CChar) -> Ptr CChar
B.GHT.cstringUnpackPtr [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result''
        [(Text, PtrWrapped (Ptr CChar))]
result'''' <- (Ptr CChar -> IO Text)
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
-> IO [(Text, PtrWrapped (Ptr CChar))]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Ptr CChar, PtrWrapped (Ptr CChar))]
result'''
        let result''''' :: [(Text, Ptr CChar)]
result''''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(Text, PtrWrapped (Ptr CChar))] -> [(Text, Ptr CChar)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr CChar) -> Ptr CChar
B.GHT.cstringUnpackPtr [(Text, PtrWrapped (Ptr CChar))]
result''''
        [(Text, Text)]
result'''''' <- (Ptr CChar -> IO Text) -> [(Text, Ptr CChar)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Text, Ptr CChar)]
result'''''
        let result''''''' :: Map Text Text
result''''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
result''''''
        Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result'
        Map Text Text -> IO (Map Text Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result'''''''
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
header'
    Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Map Text Text)
maybeResult


-- function header_parse_semi_param_list
-- Args: [ Arg
--           { argCName = "header"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a header value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TGHash (TBasicType TUTF8) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "soup_header_parse_semi_param_list" soup_header_parse_semi_param_list :: 
    CString ->                              -- header : TBasicType TUTF8
    IO (Ptr (GHashTable CString CString))

-- | Parses a header which is a semicolon-delimited list of something
-- like: @token [ \"=\" ( token | quoted-string ) ]@.
-- 
-- Tokens that don\'t have an associated value will still be added to
-- the resulting hash table, but with a 'P.Nothing' value.
-- 
-- This also handles RFC5987 encoding (which in HTTP is mostly used
-- for giving UTF8-encoded filenames in the Content-Disposition
-- header).
headerParseSemiParamList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@header@/: a header value
    -> m (Map.Map T.Text T.Text)
    -- ^ __Returns:__ a
    --   t'GI.GLib.Structs.HashTable.HashTable' of list elements, which can be freed with
    --   [func/@headerFreeParamList@/].
headerParseSemiParamList :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Map Text Text)
headerParseSemiParamList Text
header = IO (Map Text Text) -> m (Map Text Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Map Text Text) -> m (Map Text Text))
-> IO (Map Text Text) -> m (Map Text Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
header' <- Text -> IO (Ptr CChar)
textToCString Text
header
    Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result <- Ptr CChar -> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
soup_header_parse_semi_param_list Ptr CChar
header'
    Text -> Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"headerParseSemiParamList" Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result
    [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result' <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> IO [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result
    let result'' :: [(Ptr CChar, PtrWrapped (Ptr CChar))]
result'' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr CChar) -> Ptr CChar
B.GHT.cstringUnpackPtr [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result'
    [(Text, PtrWrapped (Ptr CChar))]
result''' <- (Ptr CChar -> IO Text)
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
-> IO [(Text, PtrWrapped (Ptr CChar))]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Ptr CChar, PtrWrapped (Ptr CChar))]
result''
    let result'''' :: [(Text, Ptr CChar)]
result'''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(Text, PtrWrapped (Ptr CChar))] -> [(Text, Ptr CChar)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr CChar) -> Ptr CChar
B.GHT.cstringUnpackPtr [(Text, PtrWrapped (Ptr CChar))]
result'''
    [(Text, Text)]
result''''' <- (Ptr CChar -> IO Text) -> [(Text, Ptr CChar)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Text, Ptr CChar)]
result''''
    let result'''''' :: Map Text Text
result'''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
result'''''
    Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
header'
    Map Text Text -> IO (Map Text Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result''''''


-- function header_parse_quality_list
-- Args: [ Arg
--           { argCName = "header"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a header value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "unacceptable"
--           , argType = TGSList (TBasicType TUTF8)
--           , direction = DirectionOut
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "on\n  return, will contain a list of unacceptable values"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TGSList (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "soup_header_parse_quality_list" soup_header_parse_quality_list :: 
    CString ->                              -- header : TBasicType TUTF8
    Ptr (Ptr (GSList CString)) ->           -- unacceptable : TGSList (TBasicType TUTF8)
    IO (Ptr (GSList CString))

-- | Parses a header whose content is a list of items with optional
-- \"qvalue\"s (eg, Accept, Accept-Charset, Accept-Encoding,
-- Accept-Language, TE).
-- 
-- If /@unacceptable@/ is not 'P.Nothing', then on return, it will contain the
-- items with qvalue 0. Either way, those items will be removed from
-- the main list.
headerParseQualityList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@header@/: a header value
    -> m (([T.Text], [T.Text]))
    -- ^ __Returns:__ a t'GI.GLib.Structs.SList.SList' of
    --   acceptable values (as allocated strings), highest-qvalue first.
headerParseQualityList :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m ([Text], [Text])
headerParseQualityList Text
header = IO ([Text], [Text]) -> m ([Text], [Text])
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ([Text], [Text]) -> m ([Text], [Text]))
-> IO ([Text], [Text]) -> m ([Text], [Text])
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
header' <- Text -> IO (Ptr CChar)
textToCString Text
header
    Ptr (Ptr (GSList (Ptr CChar)))
unacceptable <- IO (Ptr (Ptr (GSList (Ptr CChar))))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GSList CString)))
    Ptr (GSList (Ptr CChar))
result <- Ptr CChar
-> Ptr (Ptr (GSList (Ptr CChar))) -> IO (Ptr (GSList (Ptr CChar)))
soup_header_parse_quality_list Ptr CChar
header' Ptr (Ptr (GSList (Ptr CChar)))
unacceptable
    [Ptr CChar]
result' <- Ptr (GSList (Ptr CChar)) -> IO [Ptr CChar]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr CChar))
result
    [Text]
result'' <- (Ptr CChar -> IO Text) -> [Ptr CChar] -> IO [Text]
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 HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [Ptr CChar]
result'
    (Ptr CChar -> IO ()) -> Ptr (GSList (Ptr CChar)) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()
mapGSList Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GSList (Ptr CChar))
result
    Ptr (GSList (Ptr CChar)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr CChar))
result
    Ptr (GSList (Ptr CChar))
unacceptable' <- Ptr (Ptr (GSList (Ptr CChar))) -> IO (Ptr (GSList (Ptr CChar)))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GSList (Ptr CChar)))
unacceptable
    [Ptr CChar]
unacceptable'' <- Ptr (GSList (Ptr CChar)) -> IO [Ptr CChar]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr CChar))
unacceptable'
    [Text]
unacceptable''' <- (Ptr CChar -> IO Text) -> [Ptr CChar] -> IO [Text]
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 HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [Ptr CChar]
unacceptable''
    (Ptr CChar -> IO ()) -> Ptr (GSList (Ptr CChar)) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()
mapGSList Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GSList (Ptr CChar))
unacceptable'
    Ptr (GSList (Ptr CChar)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr CChar))
unacceptable'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
header'
    Ptr (Ptr (GSList (Ptr CChar))) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GSList (Ptr CChar)))
unacceptable
    ([Text], [Text]) -> IO ([Text], [Text])
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Text]
result'', [Text]
unacceptable''')


-- function header_parse_param_list_strict
-- Args: [ Arg
--           { argCName = "header"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a header value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TGHash (TBasicType TUTF8) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "soup_header_parse_param_list_strict" soup_header_parse_param_list_strict :: 
    CString ->                              -- header : TBasicType TUTF8
    IO (Ptr (GHashTable CString CString))

-- | A strict version of [func/@headerParseParamList@/]
-- that bails out if there are duplicate parameters.
-- 
-- Note that this function will treat RFC5987-encoded
-- parameters as duplicated if an ASCII version is also
-- present. For header fields that might contain
-- RFC5987-encoded parameters, use
-- [func/@headerParseParamList@/] instead.
headerParseParamListStrict ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@header@/: a header value
    -> m (Maybe (Map.Map T.Text T.Text))
    -- ^ __Returns:__ 
    --   a t'GI.GLib.Structs.HashTable.HashTable' of list elements, which can be freed with
    --   [func/@headerFreeParamList@/] or 'P.Nothing' if there are duplicate
    --   elements.
headerParseParamListStrict :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe (Map Text Text))
headerParseParamListStrict Text
header = IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text))
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text)))
-> IO (Maybe (Map Text Text)) -> m (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
header' <- Text -> IO (Ptr CChar)
textToCString Text
header
    Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result <- Ptr CChar -> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
soup_header_parse_param_list_strict Ptr CChar
header'
    Maybe (Map Text Text)
maybeResult <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> (Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result ((Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
 -> IO (Maybe (Map Text Text)))
-> (Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ \Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result' -> do
        [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result'' <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> IO [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result'
        let result''' :: [(Ptr CChar, PtrWrapped (Ptr CChar))]
result''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr CChar) -> Ptr CChar
B.GHT.cstringUnpackPtr [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result''
        [(Text, PtrWrapped (Ptr CChar))]
result'''' <- (Ptr CChar -> IO Text)
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
-> IO [(Text, PtrWrapped (Ptr CChar))]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Ptr CChar, PtrWrapped (Ptr CChar))]
result'''
        let result''''' :: [(Text, Ptr CChar)]
result''''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(Text, PtrWrapped (Ptr CChar))] -> [(Text, Ptr CChar)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr CChar) -> Ptr CChar
B.GHT.cstringUnpackPtr [(Text, PtrWrapped (Ptr CChar))]
result''''
        [(Text, Text)]
result'''''' <- (Ptr CChar -> IO Text) -> [(Text, Ptr CChar)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Text, Ptr CChar)]
result'''''
        let result''''''' :: Map Text Text
result''''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
result''''''
        Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result'
        Map Text Text -> IO (Map Text Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result'''''''
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
header'
    Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe (Map Text Text)
maybeResult


-- function header_parse_param_list
-- Args: [ Arg
--           { argCName = "header"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a header value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TGHash (TBasicType TUTF8) (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "soup_header_parse_param_list" soup_header_parse_param_list :: 
    CString ->                              -- header : TBasicType TUTF8
    IO (Ptr (GHashTable CString CString))

-- | Parses a header which is a comma-delimited list of something like:
-- @token [ \"=\" ( token | quoted-string ) ]@.
-- 
-- Tokens that don\'t have an associated value will still be added to
-- the resulting hash table, but with a 'P.Nothing' value.
-- 
-- This also handles RFC5987 encoding (which in HTTP is mostly used
-- for giving UTF8-encoded filenames in the Content-Disposition
-- header).
headerParseParamList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@header@/: a header value
    -> m (Map.Map T.Text T.Text)
    -- ^ __Returns:__ a
    --   t'GI.GLib.Structs.HashTable.HashTable' of list elements, which can be freed with
    --   [func/@headerFreeParamList@/].
headerParseParamList :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Map Text Text)
headerParseParamList Text
header = IO (Map Text Text) -> m (Map Text Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Map Text Text) -> m (Map Text Text))
-> IO (Map Text Text) -> m (Map Text Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
header' <- Text -> IO (Ptr CChar)
textToCString Text
header
    Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result <- Ptr CChar -> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
soup_header_parse_param_list Ptr CChar
header'
    Text -> Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"headerParseParamList" Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result
    [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result' <- Ptr (GHashTable (Ptr CChar) (Ptr CChar))
-> IO [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result
    let result'' :: [(Ptr CChar, PtrWrapped (Ptr CChar))]
result'' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped (Ptr CChar) -> Ptr CChar
B.GHT.cstringUnpackPtr [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
result'
    [(Text, PtrWrapped (Ptr CChar))]
result''' <- (Ptr CChar -> IO Text)
-> [(Ptr CChar, PtrWrapped (Ptr CChar))]
-> IO [(Text, PtrWrapped (Ptr CChar))]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Ptr CChar, PtrWrapped (Ptr CChar))]
result''
    let result'''' :: [(Text, Ptr CChar)]
result'''' = (PtrWrapped (Ptr CChar) -> Ptr CChar)
-> [(Text, PtrWrapped (Ptr CChar))] -> [(Text, Ptr CChar)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped (Ptr CChar) -> Ptr CChar
B.GHT.cstringUnpackPtr [(Text, PtrWrapped (Ptr CChar))]
result'''
    [(Text, Text)]
result''''' <- (Ptr CChar -> IO Text) -> [(Text, Ptr CChar)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [(Text, Ptr CChar)]
result''''
    let result'''''' :: Map Text Text
result'''''' = [(Text, Text)] -> Map Text Text
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList [(Text, Text)]
result'''''
    Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
header'
    Map Text Text -> IO (Map Text Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result''''''


-- function header_parse_list
-- Args: [ Arg
--           { argCName = "header"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a header value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TGSList (TBasicType TUTF8))
-- throws : False
-- Skip return : False

foreign import ccall "soup_header_parse_list" soup_header_parse_list :: 
    CString ->                              -- header : TBasicType TUTF8
    IO (Ptr (GSList CString))

-- | Parses a header whose content is described by RFC2616 as @#something@.
-- 
-- \"something\" does not itself contain commas, except as part of quoted-strings.
headerParseList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@header@/: a header value
    -> m [T.Text]
    -- ^ __Returns:__ a t'GI.GLib.Structs.SList.SList' of
    --   list elements, as allocated strings
headerParseList :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Text -> m [Text]
headerParseList Text
header = IO [Text] -> m [Text]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Text] -> m [Text]) -> IO [Text] -> m [Text]
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
header' <- Text -> IO (Ptr CChar)
textToCString Text
header
    Ptr (GSList (Ptr CChar))
result <- Ptr CChar -> IO (Ptr (GSList (Ptr CChar)))
soup_header_parse_list Ptr CChar
header'
    [Ptr CChar]
result' <- Ptr (GSList (Ptr CChar)) -> IO [Ptr CChar]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr CChar))
result
    [Text]
result'' <- (Ptr CChar -> IO Text) -> [Ptr CChar] -> IO [Text]
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 HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText [Ptr CChar]
result'
    (Ptr CChar -> IO ()) -> Ptr (GSList (Ptr CChar)) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()
mapGSList Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GSList (Ptr CChar))
result
    Ptr (GSList (Ptr CChar)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr CChar))
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
header'
    [Text] -> IO [Text]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
result''


-- function header_g_string_append_param_quoted
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GString being used to construct an HTTP header value"
--                 , 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 "a parameter 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 "a parameter value" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_header_g_string_append_param_quoted" soup_header_g_string_append_param_quoted :: 
    Ptr GLib.String.String ->               -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO ()

-- | Appends something like @name=\"value\"@ to
-- /@string@/, taking care to escape any quotes or backslashes in /@value@/.
-- 
-- If /@value@/ is (non-ASCII) UTF-8, this will instead use RFC 5987
-- encoding, just like [func/@headerGStringAppendParam@/].
headerGStringAppendParamQuoted ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.String.String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String' being used to construct an HTTP header value
    -> T.Text
    -- ^ /@name@/: a parameter name
    -> T.Text
    -- ^ /@value@/: a parameter value
    -> m ()
headerGStringAppendParamQuoted :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Text -> m ()
headerGStringAppendParamQuoted String
string 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 String
string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
    Ptr CChar
value' <- Text -> IO (Ptr CChar)
textToCString Text
value
    Ptr String -> Ptr CChar -> Ptr CChar -> IO ()
soup_header_g_string_append_param_quoted Ptr String
string' Ptr CChar
name' Ptr CChar
value'
    String -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
value'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- function header_g_string_append_param
-- Args: [ Arg
--           { argCName = "string"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "String" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #GString being used to construct an HTTP header value"
--                 , 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 "a parameter name" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a parameter value, 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_header_g_string_append_param" soup_header_g_string_append_param :: 
    Ptr GLib.String.String ->               -- string : TInterface (Name {namespace = "GLib", name = "String"})
    CString ->                              -- name : TBasicType TUTF8
    CString ->                              -- value : TBasicType TUTF8
    IO ()

-- | Appends something like @name=value@ to /@string@/, taking care to quote /@value@/
-- if needed, and if so, to escape any quotes or backslashes in /@value@/.
-- 
-- Alternatively, if /@value@/ is a non-ASCII UTF-8 string, it will be
-- appended using RFC5987 syntax. Although in theory this is supposed
-- to work anywhere in HTTP that uses this style of parameter, in
-- reality, it can only be used portably with the Content-Disposition
-- \"filename\" parameter.
-- 
-- If /@value@/ is 'P.Nothing', this will just append /@name@/ to /@string@/.
headerGStringAppendParam ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.String.String
    -- ^ /@string@/: a t'GI.GLib.Structs.String.String' being used to construct an HTTP header value
    -> T.Text
    -- ^ /@name@/: a parameter name
    -> Maybe (T.Text)
    -- ^ /@value@/: a parameter value, or 'P.Nothing'
    -> m ()
headerGStringAppendParam :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
String -> Text -> Maybe Text -> m ()
headerGStringAppendParam String
string Text
name Maybe 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 String
string' <- String -> IO (Ptr String)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
string
    Ptr CChar
name' <- Text -> IO (Ptr CChar)
textToCString Text
name
    Ptr CChar
maybeValue <- case Maybe Text
value of
        Maybe Text
Nothing -> Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
forall a. Ptr a
nullPtr
        Just Text
jValue -> do
            Ptr CChar
jValue' <- Text -> IO (Ptr CChar)
textToCString Text
jValue
            Ptr CChar -> IO (Ptr CChar)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CChar
jValue'
    Ptr String -> Ptr CChar -> Ptr CChar -> IO ()
soup_header_g_string_append_param Ptr String
string' Ptr CChar
name' Ptr CChar
maybeValue
    String -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
name'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
maybeValue
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- function header_free_param_list
-- Args: [ Arg
--           { argCName = "param_list"
--           , argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "a #GHashTable returned from\n  [func@header_parse_param_list] or [func@header_parse_semi_param_list]"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_header_free_param_list" soup_header_free_param_list :: 
    Ptr (GHashTable CString CString) ->     -- param_list : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO ()

-- | Frees /@paramList@/.
headerFreeParamList ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Map.Map T.Text T.Text
    -- ^ /@paramList@/: a t'GI.GLib.Structs.HashTable.HashTable' returned from
    --   [func/@headerParseParamList@/] or [func/@headerParseSemiParamList@/]
    -> m ()
headerFreeParamList :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Map Text Text -> m ()
headerFreeParamList Map Text Text
paramList = 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
    let paramList' :: [(Text, Text)]
paramList' = Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
paramList
    [(Ptr CChar, Text)]
paramList'' <- (Text -> IO (Ptr CChar))
-> [(Text, Text)] -> IO [(Ptr CChar, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO (Ptr CChar)
textToCString [(Text, Text)]
paramList'
    [(Ptr CChar, Ptr CChar)]
paramList''' <- (Text -> IO (Ptr CChar))
-> [(Ptr CChar, Text)] -> IO [(Ptr CChar, Ptr CChar)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO (Ptr CChar)
textToCString [(Ptr CChar, Text)]
paramList''
    let paramList'''' :: [(PtrWrapped (Ptr CChar), Ptr CChar)]
paramList'''' = (Ptr CChar -> PtrWrapped (Ptr CChar))
-> [(Ptr CChar, Ptr CChar)]
-> [(PtrWrapped (Ptr CChar), Ptr CChar)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst Ptr CChar -> PtrWrapped (Ptr CChar)
B.GHT.cstringPackPtr [(Ptr CChar, Ptr CChar)]
paramList'''
    let paramList''''' :: [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
paramList''''' = (Ptr CChar -> PtrWrapped (Ptr CChar))
-> [(PtrWrapped (Ptr CChar), Ptr CChar)]
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond Ptr CChar -> PtrWrapped (Ptr CChar)
B.GHT.cstringPackPtr [(PtrWrapped (Ptr CChar), Ptr CChar)]
paramList''''
    Ptr (GHashTable (Ptr CChar) (Ptr CChar))
paramList'''''' <- GHashFunc (Ptr CChar)
-> GEqualFunc (Ptr CChar)
-> Maybe (GDestroyNotify (Ptr CChar))
-> Maybe (GDestroyNotify (Ptr CChar))
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc (Ptr CChar)
gStrHash GEqualFunc (Ptr CChar)
gStrEqual (GDestroyNotify (Ptr CChar) -> Maybe (GDestroyNotify (Ptr CChar))
forall a. a -> Maybe a
Just GDestroyNotify (Ptr CChar)
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify (Ptr CChar) -> Maybe (GDestroyNotify (Ptr CChar))
forall a. a -> Maybe a
Just GDestroyNotify (Ptr CChar)
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
paramList'''''
    Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
soup_header_free_param_list Ptr (GHashTable (Ptr CChar) (Ptr CChar))
paramList''''''
    Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
paramList''''''
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- function header_contains
-- Args: [ Arg
--           { argCName = "header"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "An HTTP header suitable for parsing with\n  [func@header_parse_list]"
--                 , 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 "a token" , 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_header_contains" soup_header_contains :: 
    CString ->                              -- header : TBasicType TUTF8
    CString ->                              -- token : TBasicType TUTF8
    IO CInt

-- | Parses /@header@/ to see if it contains the token /@token@/ (matched
-- case-insensitively).
-- 
-- Note that this can\'t be used with lists that have qvalues.
headerContains ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@header@/: An HTTP header suitable for parsing with
    --   [func/@headerParseList@/]
    -> T.Text
    -- ^ /@token@/: a token
    -> m Bool
    -- ^ __Returns:__ whether or not /@header@/ contains /@token@/
headerContains :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> Text -> m Bool
headerContains Text
header 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 CChar
header' <- Text -> IO (Ptr CChar)
textToCString Text
header
    Ptr CChar
token' <- Text -> IO (Ptr CChar)
textToCString Text
token
    CInt
result <- Ptr CChar -> Ptr CChar -> IO CInt
soup_header_contains Ptr CChar
header' Ptr CChar
token'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
header'
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
token'
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'


-- function get_minor_version
-- Args: []
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_get_minor_version" soup_get_minor_version :: 
    IO Word32

-- | Returns the minor version number of the libsoup library.
-- 
-- e.g. in libsoup version 2.42.0 this is 42.
-- 
-- This function is in the library, so it represents the libsoup library
-- your code is running against. Contrast with the 'GI.Soup.Constants.MINOR_VERSION'
-- macro, which represents the minor version of the libsoup headers you
-- have included when compiling your code.
getMinorVersion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Word32
    -- ^ __Returns:__ the minor version number of the libsoup library
getMinorVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
getMinorVersion  = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Word32
result <- IO Word32
soup_get_minor_version
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result


-- function get_micro_version
-- Args: []
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_get_micro_version" soup_get_micro_version :: 
    IO Word32

-- | Returns the micro version number of the libsoup library.
-- 
-- e.g. in libsoup version 2.42.0 this is 0.
-- 
-- This function is in the library, so it represents the libsoup library
-- your code is running against. Contrast with the 'GI.Soup.Constants.MICRO_VERSION'
-- macro, which represents the micro version of the libsoup headers you
-- have included when compiling your code.
getMicroVersion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Word32
    -- ^ __Returns:__ the micro version number of the libsoup library
getMicroVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
getMicroVersion  = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Word32
result <- IO Word32
soup_get_micro_version
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result


-- function get_major_version
-- Args: []
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_get_major_version" soup_get_major_version :: 
    IO Word32

-- | Returns the major version number of the libsoup library.
-- 
-- e.g. in libsoup version 2.42.0 this is 2.
-- 
-- This function is in the library, so it represents the libsoup library
-- your code is running against. Contrast with the 'GI.Soup.Constants.MAJOR_VERSION'
-- macro, which represents the major version of the libsoup headers you
-- have included when compiling your code.
getMajorVersion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Word32
    -- ^ __Returns:__ the major version number of the libsoup library
getMajorVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
getMajorVersion  = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Word32
result <- IO Word32
soup_get_major_version
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result


-- function form_encode_hash
-- Args: [ Arg
--           { argCName = "form_data_set"
--           , argType = TGHash (TBasicType TUTF8) (TBasicType TUTF8)
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a hash table containing\n  name/value pairs (as strings)"
--                 , 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_form_encode_hash" soup_form_encode_hash :: 
    Ptr (GHashTable CString CString) ->     -- form_data_set : TGHash (TBasicType TUTF8) (TBasicType TUTF8)
    IO CString

-- | Encodes /@formDataSet@/ into a value of type
-- \"application\/x-www-form-urlencoded\".
-- 
-- Encodes as defined in the HTML 4.01 spec.
-- 
-- Note that the HTML spec states that \"The control names\/values are
-- listed in the order they appear in the document.\" Since this method
-- takes a hash table, it cannot enforce that; if you care about the
-- ordering of the form fields, use [func/@formEncodeDatalist@/].
-- 
-- See also: [ctor/@message@/.new_from_encoded_form].
formEncodeHash ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Map.Map T.Text T.Text
    -- ^ /@formDataSet@/: a hash table containing
    --   name\/value pairs (as strings)
    -> m T.Text
    -- ^ __Returns:__ the encoded form
formEncodeHash :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Map Text Text -> m Text
formEncodeHash Map Text Text
formDataSet = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    let formDataSet' :: [(Text, Text)]
formDataSet' = Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
formDataSet
    [(Ptr CChar, Text)]
formDataSet'' <- (Text -> IO (Ptr CChar))
-> [(Text, Text)] -> IO [(Ptr CChar, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO (Ptr CChar)
textToCString [(Text, Text)]
formDataSet'
    [(Ptr CChar, Ptr CChar)]
formDataSet''' <- (Text -> IO (Ptr CChar))
-> [(Ptr CChar, Text)] -> IO [(Ptr CChar, Ptr CChar)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO (Ptr CChar)
textToCString [(Ptr CChar, Text)]
formDataSet''
    let formDataSet'''' :: [(PtrWrapped (Ptr CChar), Ptr CChar)]
formDataSet'''' = (Ptr CChar -> PtrWrapped (Ptr CChar))
-> [(Ptr CChar, Ptr CChar)]
-> [(PtrWrapped (Ptr CChar), Ptr CChar)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst Ptr CChar -> PtrWrapped (Ptr CChar)
B.GHT.cstringPackPtr [(Ptr CChar, Ptr CChar)]
formDataSet'''
    let formDataSet''''' :: [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
formDataSet''''' = (Ptr CChar -> PtrWrapped (Ptr CChar))
-> [(PtrWrapped (Ptr CChar), Ptr CChar)]
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond Ptr CChar -> PtrWrapped (Ptr CChar)
B.GHT.cstringPackPtr [(PtrWrapped (Ptr CChar), Ptr CChar)]
formDataSet''''
    Ptr (GHashTable (Ptr CChar) (Ptr CChar))
formDataSet'''''' <- GHashFunc (Ptr CChar)
-> GEqualFunc (Ptr CChar)
-> Maybe (GDestroyNotify (Ptr CChar))
-> Maybe (GDestroyNotify (Ptr CChar))
-> [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
-> IO (Ptr (GHashTable (Ptr CChar) (Ptr CChar)))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc (Ptr CChar)
gStrHash GEqualFunc (Ptr CChar)
gStrEqual (GDestroyNotify (Ptr CChar) -> Maybe (GDestroyNotify (Ptr CChar))
forall a. a -> Maybe a
Just GDestroyNotify (Ptr CChar)
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify (Ptr CChar) -> Maybe (GDestroyNotify (Ptr CChar))
forall a. a -> Maybe a
Just GDestroyNotify (Ptr CChar)
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped (Ptr CChar), PtrWrapped (Ptr CChar))]
formDataSet'''''
    Ptr CChar
result <- Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO (Ptr CChar)
soup_form_encode_hash Ptr (GHashTable (Ptr CChar) (Ptr CChar))
formDataSet''''''
    Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"formEncodeHash" Ptr CChar
result
    Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
    Ptr (GHashTable (Ptr CChar) (Ptr CChar)) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable (Ptr CChar) (Ptr CChar))
formDataSet''''''
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'


-- function form_encode_datalist
-- Args: [ Arg
--           { argCName = "form_data_set"
--           , argType = TInterface Name { namespace = "GLib" , name = "Data" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a datalist containing name/value pairs"
--                 , 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_form_encode_datalist" soup_form_encode_datalist :: 
    Ptr GLib.Data.Data ->                   -- form_data_set : TInterface (Name {namespace = "GLib", name = "Data"})
    IO CString

-- | Encodes /@formDataSet@/ into a value of type
-- \"application\/x-www-form-urlencoded\".
-- 
-- Encodes as defined in the HTML 4.01 spec. Unlike [func/@formEncodeHash@/],
-- this preserves the ordering of the form elements, which may be required in
-- some situations.
-- 
-- See also: [ctor/@message@/.new_from_encoded_form].
formEncodeDatalist ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.Data.Data
    -- ^ /@formDataSet@/: a datalist containing name\/value pairs
    -> m T.Text
    -- ^ __Returns:__ the encoded form
formEncodeDatalist :: forall (m :: * -> *). (HasCallStack, MonadIO m) => Data -> m Text
formEncodeDatalist Data
formDataSet = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr Data
formDataSet' <- Data -> IO (Ptr Data)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Data
formDataSet
    Ptr CChar
result <- Ptr Data -> IO (Ptr CChar)
soup_form_encode_datalist Ptr Data
formDataSet'
    Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"formEncodeDatalist" Ptr CChar
result
    Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
    Data -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Data
formDataSet
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'


-- function form_decode_multipart
-- XXX Could not generate function form_decode_multipart

-- Not implemented: Hash table argument with transfer = Container? result'

-- function form_decode
-- XXX Could not generate function form_decode

-- Not implemented: Hash table argument with transfer = Container? result

-- function date_time_to_string
-- Args: [ Arg
--           { argCName = "date"
--           , argType =
--               TInterface Name { namespace = "GLib" , name = "DateTime" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GDateTime" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "format"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "DateFormat" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the format to generate the date in"
--                 , 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_date_time_to_string" soup_date_time_to_string :: 
    Ptr GLib.DateTime.DateTime ->           -- date : TInterface (Name {namespace = "GLib", name = "DateTime"})
    CUInt ->                                -- format : TInterface (Name {namespace = "Soup", name = "DateFormat"})
    IO CString

-- | Converts /@date@/ to a string in the format described by /@format@/.
dateTimeToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    GLib.DateTime.DateTime
    -- ^ /@date@/: a t'GI.GLib.Structs.DateTime.DateTime'
    -> Soup.Enums.DateFormat
    -- ^ /@format@/: the format to generate the date in
    -> m T.Text
    -- ^ __Returns:__ /@date@/ as a string or 'P.Nothing'
dateTimeToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DateTime -> DateFormat -> m Text
dateTimeToString DateTime
date DateFormat
format = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr DateTime
date' <- DateTime -> IO (Ptr DateTime)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DateTime
date
    let format' :: CUInt
format' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (DateFormat -> Int) -> DateFormat -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DateFormat -> Int
forall a. Enum a => a -> Int
fromEnum) DateFormat
format
    Ptr CChar
result <- Ptr DateTime -> CUInt -> IO (Ptr CChar)
soup_date_time_to_string Ptr DateTime
date' CUInt
format'
    Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dateTimeToString" Ptr CChar
result
    Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
    DateTime -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DateTime
date
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'


-- function date_time_new_from_http_string
-- Args: [ Arg
--           { argCName = "date_string"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The date as a string"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "DateTime" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_date_time_new_from_http_string" soup_date_time_new_from_http_string :: 
    CString ->                              -- date_string : TBasicType TUTF8
    IO (Ptr GLib.DateTime.DateTime)

-- | Parses /@dateString@/ and tries to extract a date from it.
-- 
-- This recognizes all of the \"HTTP-date\" formats from RFC 2616, RFC 2822 dates,
-- and reasonable approximations thereof. (Eg, it is lenient about whitespace,
-- leading \"0\"s, etc.)
dateTimeNewFromHttpString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@dateString@/: The date as a string
    -> m (Maybe GLib.DateTime.DateTime)
    -- ^ __Returns:__ a new t'GI.GLib.Structs.DateTime.DateTime', or 'P.Nothing' if /@dateString@/
    --   could not be parsed.
dateTimeNewFromHttpString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m (Maybe DateTime)
dateTimeNewFromHttpString Text
dateString = IO (Maybe DateTime) -> m (Maybe DateTime)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe DateTime) -> m (Maybe DateTime))
-> IO (Maybe DateTime) -> m (Maybe DateTime)
forall a b. (a -> b) -> a -> b
$ do
    Ptr CChar
dateString' <- Text -> IO (Ptr CChar)
textToCString Text
dateString
    Ptr DateTime
result <- Ptr CChar -> IO (Ptr DateTime)
soup_date_time_new_from_http_string Ptr CChar
dateString'
    Maybe DateTime
maybeResult <- Ptr DateTime
-> (Ptr DateTime -> IO DateTime) -> IO (Maybe DateTime)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DateTime
result ((Ptr DateTime -> IO DateTime) -> IO (Maybe DateTime))
-> (Ptr DateTime -> IO DateTime) -> IO (Maybe DateTime)
forall a b. (a -> b) -> a -> b
$ \Ptr DateTime
result' -> do
        DateTime
result'' <- ((ManagedPtr DateTime -> DateTime) -> Ptr DateTime -> IO DateTime
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DateTime -> DateTime
GLib.DateTime.DateTime) Ptr DateTime
result'
        DateTime -> IO DateTime
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DateTime
result''
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
dateString'
    Maybe DateTime -> IO (Maybe DateTime)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DateTime
maybeResult


-- function cookies_to_response
-- Args: [ Arg
--           { argCName = "cookies"
--           , argType =
--               TGSList (TInterface Name { namespace = "Soup" , name = "Cookie" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSList of #SoupCookie"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookies_to_response" soup_cookies_to_response :: 
    Ptr (GSList (Ptr Soup.Cookie.Cookie)) -> -- cookies : TGSList (TInterface (Name {namespace = "Soup", name = "Cookie"}))
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO ()

-- | Appends a \"Set-Cookie\" response header to /@msg@/ for each cookie in
-- /@cookies@/.
-- 
-- This is in addition to any other \"Set-Cookie\" headers
-- /@msg@/ may already have.
cookiesToResponse ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
    [Soup.Cookie.Cookie]
    -- ^ /@cookies@/: a t'GI.GLib.Structs.SList.SList' of t'GI.Soup.Structs.Cookie.Cookie'
    -> a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m ()
cookiesToResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
[Cookie] -> a -> m ()
cookiesToResponse [Cookie]
cookies a
msg = 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 Cookie]
cookies' <- (Cookie -> IO (Ptr Cookie)) -> [Cookie] -> IO [Ptr Cookie]
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 Cookie -> IO (Ptr Cookie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [Cookie]
cookies
    Ptr (GSList (Ptr Cookie))
cookies'' <- [Ptr Cookie] -> IO (Ptr (GSList (Ptr Cookie)))
forall a. [Ptr a] -> IO (Ptr (GSList (Ptr a)))
packGSList [Ptr Cookie]
cookies'
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr (GSList (Ptr Cookie)) -> Ptr Message -> IO ()
soup_cookies_to_response Ptr (GSList (Ptr Cookie))
cookies'' Ptr Message
msg'
    (Cookie -> IO ()) -> [Cookie] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Cookie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Cookie]
cookies
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Ptr (GSList (Ptr Cookie)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Cookie))
cookies''
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- function cookies_to_request
-- Args: [ Arg
--           { argCName = "cookies"
--           , argType =
--               TGSList (TInterface Name { namespace = "Soup" , name = "Cookie" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSList of #SoupCookie"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookies_to_request" soup_cookies_to_request :: 
    Ptr (GSList (Ptr Soup.Cookie.Cookie)) -> -- cookies : TGSList (TInterface (Name {namespace = "Soup", name = "Cookie"}))
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO ()

-- | Adds the name and value of each cookie in /@cookies@/ to /@msg@/\'s
-- \"Cookie\" request.
-- 
-- If /@msg@/ already has a \"Cookie\" request header, these cookies will be appended
-- to the cookies already present. Be careful that you do not append the same
-- cookies twice, eg, when requeuing a message.
cookiesToRequest ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
    [Soup.Cookie.Cookie]
    -- ^ /@cookies@/: a t'GI.GLib.Structs.SList.SList' of t'GI.Soup.Structs.Cookie.Cookie'
    -> a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m ()
cookiesToRequest :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
[Cookie] -> a -> m ()
cookiesToRequest [Cookie]
cookies a
msg = 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 Cookie]
cookies' <- (Cookie -> IO (Ptr Cookie)) -> [Cookie] -> IO [Ptr Cookie]
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 Cookie -> IO (Ptr Cookie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [Cookie]
cookies
    Ptr (GSList (Ptr Cookie))
cookies'' <- [Ptr Cookie] -> IO (Ptr (GSList (Ptr Cookie)))
forall a. [Ptr a] -> IO (Ptr (GSList (Ptr a)))
packGSList [Ptr Cookie]
cookies'
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr (GSList (Ptr Cookie)) -> Ptr Message -> IO ()
soup_cookies_to_request Ptr (GSList (Ptr Cookie))
cookies'' Ptr Message
msg'
    (Cookie -> IO ()) -> [Cookie] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Cookie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Cookie]
cookies
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Ptr (GSList (Ptr Cookie)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Cookie))
cookies''
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


-- function cookies_to_cookie_header
-- Args: [ Arg
--           { argCName = "cookies"
--           , argType =
--               TGSList (TInterface Name { namespace = "Soup" , name = "Cookie" })
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GSList of #SoupCookie"
--                 , 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_cookies_to_cookie_header" soup_cookies_to_cookie_header :: 
    Ptr (GSList (Ptr Soup.Cookie.Cookie)) -> -- cookies : TGSList (TInterface (Name {namespace = "Soup", name = "Cookie"}))
    IO CString

-- | Serializes a [struct/@gLib@/.SList] of t'GI.Soup.Structs.Cookie.Cookie' into a string suitable for
-- setting as the value of the \"Cookie\" header.
cookiesToCookieHeader ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    [Soup.Cookie.Cookie]
    -- ^ /@cookies@/: a t'GI.GLib.Structs.SList.SList' of t'GI.Soup.Structs.Cookie.Cookie'
    -> m T.Text
    -- ^ __Returns:__ the serialization of /@cookies@/
cookiesToCookieHeader :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
[Cookie] -> m Text
cookiesToCookieHeader [Cookie]
cookies = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    [Ptr Cookie]
cookies' <- (Cookie -> IO (Ptr Cookie)) -> [Cookie] -> IO [Ptr Cookie]
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 Cookie -> IO (Ptr Cookie)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [Cookie]
cookies
    Ptr (GSList (Ptr Cookie))
cookies'' <- [Ptr Cookie] -> IO (Ptr (GSList (Ptr Cookie)))
forall a. [Ptr a] -> IO (Ptr (GSList (Ptr a)))
packGSList [Ptr Cookie]
cookies'
    Ptr CChar
result <- Ptr (GSList (Ptr Cookie)) -> IO (Ptr CChar)
soup_cookies_to_cookie_header Ptr (GSList (Ptr Cookie))
cookies''
    Text -> Ptr CChar -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"cookiesToCookieHeader" Ptr CChar
result
    Text
result' <- HasCallStack => Ptr CChar -> IO Text
Ptr CChar -> IO Text
cstringToText Ptr CChar
result
    Ptr CChar -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CChar
result
    (Cookie -> IO ()) -> [Cookie] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Cookie -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Cookie]
cookies
    Ptr (GSList (Ptr Cookie)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Cookie))
cookies''
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'


-- function cookies_from_response
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #SoupMessage containing a \"Set-Cookie\" response header"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGSList
--                  (TInterface Name { namespace = "Soup" , name = "Cookie" }))
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookies_from_response" soup_cookies_from_response :: 
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr (GSList (Ptr Soup.Cookie.Cookie)))

-- | Parses /@msg@/\'s Set-Cookie response headers and returns a [struct/@gLib@/.SList]
-- of @SoupCookie@s.
-- 
-- Cookies that do not specify \"path\" or \"domain\" attributes will have their
-- values defaulted from /@msg@/.
cookiesFromResponse ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message' containing a \"Set-Cookie\" response header
    -> m [Soup.Cookie.Cookie]
    -- ^ __Returns:__ a t'GI.GLib.Structs.SList.SList' of
    --   @SoupCookie@s, which can be freed with [method/@cookie@/.free].
cookiesFromResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m [Cookie]
cookiesFromResponse a
msg = IO [Cookie] -> m [Cookie]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Cookie] -> m [Cookie]) -> IO [Cookie] -> m [Cookie]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr (GSList (Ptr Cookie))
result <- Ptr Message -> IO (Ptr (GSList (Ptr Cookie)))
soup_cookies_from_response Ptr Message
msg'
    [Ptr Cookie]
result' <- Ptr (GSList (Ptr Cookie)) -> IO [Ptr Cookie]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr Cookie))
result
    [Cookie]
result'' <- (Ptr Cookie -> IO Cookie) -> [Ptr Cookie] -> IO [Cookie]
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 Cookie -> Cookie) -> Ptr Cookie -> IO Cookie
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Cookie -> Cookie
Soup.Cookie.Cookie) [Ptr Cookie]
result'
    Ptr (GSList (Ptr Cookie)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Cookie))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    [Cookie] -> IO [Cookie]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Cookie]
result''


-- function cookies_from_request
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "Message" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #SoupMessage containing a \"Cookie\" request header"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TGSList
--                  (TInterface Name { namespace = "Soup" , name = "Cookie" }))
-- throws : False
-- Skip return : False

foreign import ccall "soup_cookies_from_request" soup_cookies_from_request :: 
    Ptr Soup.Message.Message ->             -- msg : TInterface (Name {namespace = "Soup", name = "Message"})
    IO (Ptr (GSList (Ptr Soup.Cookie.Cookie)))

-- | Parses /@msg@/\'s Cookie request header and returns a [struct/@gLib@/.SList] of
-- @SoupCookie@s.
-- 
-- As the \"Cookie\" header, unlike \"Set-Cookie\", only contains cookie names and
-- values, none of the other t'GI.Soup.Structs.Cookie.Cookie' fields will be filled in. (Thus, you
-- can\'t generally pass a cookie returned from this method directly to
-- [func/@cookiesToResponse@/].)
cookiesFromRequest ::
    (B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message' containing a \"Cookie\" request header
    -> m [Soup.Cookie.Cookie]
    -- ^ __Returns:__ a t'GI.GLib.Structs.SList.SList' of
    --   @SoupCookie@s, which can be freed with [method/@cookie@/.free].
cookiesFromRequest :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsMessage a) =>
a -> m [Cookie]
cookiesFromRequest a
msg = IO [Cookie] -> m [Cookie]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [Cookie] -> m [Cookie]) -> IO [Cookie] -> m [Cookie]
forall a b. (a -> b) -> a -> b
$ do
    Ptr Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr (GSList (Ptr Cookie))
result <- Ptr Message -> IO (Ptr (GSList (Ptr Cookie)))
soup_cookies_from_request Ptr Message
msg'
    [Ptr Cookie]
result' <- Ptr (GSList (Ptr Cookie)) -> IO [Ptr Cookie]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList (Ptr Cookie))
result
    [Cookie]
result'' <- (Ptr Cookie -> IO Cookie) -> [Ptr Cookie] -> IO [Cookie]
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 Cookie -> Cookie) -> Ptr Cookie -> IO Cookie
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Cookie -> Cookie
Soup.Cookie.Cookie) [Ptr Cookie]
result'
    Ptr (GSList (Ptr Cookie)) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList (Ptr Cookie))
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    [Cookie] -> IO [Cookie]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [Cookie]
result''


-- function check_version
-- Args: [ Arg
--           { argCName = "major"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the major version to check"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "minor"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the minor version to check"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "micro"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the micro version to check"
--                 , 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_check_version" soup_check_version :: 
    Word32 ->                               -- major : TBasicType TUInt
    Word32 ->                               -- minor : TBasicType TUInt
    Word32 ->                               -- micro : TBasicType TUInt
    IO CInt

-- | Like [func/@cHECKVERSION@/], but the check for soup_check_version is
-- at runtime instead of compile time.
-- 
-- This is useful for compiling against older versions of libsoup, but using
-- features from newer versions.
checkVersion ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Word32
    -- ^ /@major@/: the major version to check
    -> Word32
    -- ^ /@minor@/: the minor version to check
    -> Word32
    -- ^ /@micro@/: the micro version to check
    -> m Bool
    -- ^ __Returns:__ 'P.True' if the version of the libsoup currently loaded
    --   is the same as or newer than the passed-in version.
checkVersion :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Word32 -> Word32 -> Word32 -> m Bool
checkVersion Word32
major Word32
minor Word32
micro = 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
    CInt
result <- Word32 -> Word32 -> Word32 -> IO CInt
soup_check_version Word32
major Word32
minor Word32
micro
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'