#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Soup.Functions
(
checkVersion ,
cookiesFromRequest ,
cookiesFromResponse ,
cookiesToCookieHeader ,
cookiesToRequest ,
cookiesToResponse ,
dateTimeNewFromHttpString ,
dateTimeToString ,
formEncodeDatalist ,
formEncodeHash ,
getMajorVersion ,
getMicroVersion ,
getMinorVersion ,
headerContains ,
headerFreeParamList ,
headerGStringAppendParam ,
headerGStringAppendParamQuoted ,
headerParseList ,
headerParseParamList ,
headerParseParamListStrict ,
headerParseQualityList ,
headerParseSemiParamList ,
headerParseSemiParamListStrict ,
headersParse ,
headersParseRequest ,
headersParseResponse ,
headersParseStatusLine ,
tldDomainIsPublicSuffix ,
tldGetBaseDomain ,
uriDecodeDataUri ,
uriEqual ,
websocketClientPrepareHandshake ,
websocketClientVerifyHandshake ,
websocketServerCheckHandshake ,
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
foreign import ccall "soup_websocket_server_process_handshake" soup_websocket_server_process_handshake ::
Ptr Soup.ServerMessage.ServerMessage ->
CString ->
Ptr CString ->
Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) ->
Ptr (Ptr (GList (Ptr Soup.WebsocketExtension.WebsocketExtension))) ->
IO CInt
websocketServerProcessHandshake ::
(B.CallStack.HasCallStack, MonadIO m, Soup.ServerMessage.IsServerMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> Maybe ([GObject.TypeClass.TypeClass])
-> m ((Bool, [Soup.WebsocketExtension.WebsocketExtension]))
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''')
foreign import ccall "soup_websocket_server_check_handshake" soup_websocket_server_check_handshake ::
Ptr Soup.ServerMessage.ServerMessage ->
CString ->
Ptr CString ->
Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) ->
Ptr (Ptr GError) ->
IO CInt
websocketServerCheckHandshake ::
(B.CallStack.HasCallStack, MonadIO m, Soup.ServerMessage.IsServerMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> Maybe ([GObject.TypeClass.TypeClass])
-> m ()
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
)
foreign import ccall "soup_websocket_client_verify_handshake" soup_websocket_client_verify_handshake ::
Ptr Soup.Message.Message ->
Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) ->
Ptr (Ptr (GList (Ptr Soup.WebsocketExtension.WebsocketExtension))) ->
Ptr (Ptr GError) ->
IO CInt
websocketClientVerifyHandshake ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe ([GObject.TypeClass.TypeClass])
-> m ([Soup.WebsocketExtension.WebsocketExtension])
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
)
foreign import ccall "soup_websocket_client_prepare_handshake" soup_websocket_client_prepare_handshake ::
Ptr Soup.Message.Message ->
CString ->
Ptr CString ->
Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) ->
IO ()
websocketClientPrepareHandshake ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> Maybe ([GObject.TypeClass.TypeClass])
-> 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 ()
foreign import ccall "soup_uri_equal" soup_uri_equal ::
Ptr GLib.Uri.Uri ->
Ptr GLib.Uri.Uri ->
IO CInt
uriEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.Uri.Uri
-> GLib.Uri.Uri
-> m Bool
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'
foreign import ccall "soup_uri_decode_data_uri" soup_uri_decode_data_uri ::
CString ->
Ptr CString ->
IO (Ptr GLib.Bytes.Bytes)
uriDecodeDataUri ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ((GLib.Bytes.Bytes, Maybe T.Text))
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')
foreign import ccall "soup_tld_get_base_domain" soup_tld_get_base_domain ::
CString ->
Ptr (Ptr GError) ->
IO CString
tldGetBaseDomain ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m T.Text
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'
)
foreign import ccall "soup_tld_domain_is_public_suffix" soup_tld_domain_is_public_suffix ::
CString ->
IO CInt
tldDomainIsPublicSuffix ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m Bool
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'
foreign import ccall "soup_headers_parse_status_line" ::
CString ->
Ptr CUInt ->
Ptr Word32 ->
Ptr CString ->
IO CInt
headersParseStatusLine ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m ((Bool, Soup.Enums.HTTPVersion, Word32, T.Text))
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'')
foreign import ccall "soup_headers_parse_response" ::
CString ->
Int32 ->
Ptr Soup.MessageHeaders.MessageHeaders ->
Ptr CUInt ->
Ptr Word32 ->
Ptr CString ->
IO CInt
headersParseResponse ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int32
-> Soup.MessageHeaders.MessageHeaders
-> m ((Bool, Soup.Enums.HTTPVersion, Word32, T.Text))
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'')
foreign import ccall "soup_headers_parse_request" ::
CString ->
Int32 ->
Ptr Soup.MessageHeaders.MessageHeaders ->
Ptr CString ->
Ptr CString ->
Ptr CUInt ->
IO Word32
headersParseRequest ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int32
-> Soup.MessageHeaders.MessageHeaders
-> m ((Word32, T.Text, T.Text, Soup.Enums.HTTPVersion))
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'')
foreign import ccall "soup_headers_parse" ::
CString ->
Int32 ->
Ptr Soup.MessageHeaders.MessageHeaders ->
IO CInt
headersParse ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int32
-> Soup.MessageHeaders.MessageHeaders
-> m Bool
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'
foreign import ccall "soup_header_parse_semi_param_list_strict" ::
CString ->
IO (Ptr (GHashTable CString CString))
headerParseSemiParamListStrict ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe (Map.Map T.Text T.Text))
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
foreign import ccall "soup_header_parse_semi_param_list" ::
CString ->
IO (Ptr (GHashTable CString CString))
headerParseSemiParamList ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Map.Map T.Text T.Text)
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''''''
foreign import ccall "soup_header_parse_quality_list" ::
CString ->
Ptr (Ptr (GSList CString)) ->
IO (Ptr (GSList CString))
headerParseQualityList ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (([T.Text], [T.Text]))
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''')
foreign import ccall "soup_header_parse_param_list_strict" ::
CString ->
IO (Ptr (GHashTable CString CString))
headerParseParamListStrict ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe (Map.Map T.Text T.Text))
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
foreign import ccall "soup_header_parse_param_list" ::
CString ->
IO (Ptr (GHashTable CString CString))
headerParseParamList ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Map.Map T.Text T.Text)
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''''''
foreign import ccall "soup_header_parse_list" ::
CString ->
IO (Ptr (GSList CString))
headerParseList ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m [T.Text]
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''
foreign import ccall "soup_header_g_string_append_param_quoted" ::
Ptr GLib.String.String ->
CString ->
CString ->
IO ()
headerGStringAppendParamQuoted ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.String.String
-> T.Text
-> T.Text
-> m ()
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 ()
foreign import ccall "soup_header_g_string_append_param" ::
Ptr GLib.String.String ->
CString ->
CString ->
IO ()
headerGStringAppendParam ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.String.String
-> T.Text
-> Maybe (T.Text)
-> m ()
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 ()
foreign import ccall "soup_header_free_param_list" ::
Ptr (GHashTable CString CString) ->
IO ()
headerFreeParamList ::
(B.CallStack.HasCallStack, MonadIO m) =>
Map.Map T.Text T.Text
-> m ()
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 ()
foreign import ccall "soup_header_contains" ::
CString ->
CString ->
IO CInt
headerContains ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m Bool
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'
foreign import ccall "soup_get_minor_version" soup_get_minor_version ::
IO Word32
getMinorVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
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
foreign import ccall "soup_get_micro_version" soup_get_micro_version ::
IO Word32
getMicroVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
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
foreign import ccall "soup_get_major_version" soup_get_major_version ::
IO Word32
getMajorVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
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
foreign import ccall "soup_form_encode_hash" soup_form_encode_hash ::
Ptr (GHashTable CString CString) ->
IO CString
formEncodeHash ::
(B.CallStack.HasCallStack, MonadIO m) =>
Map.Map T.Text T.Text
-> m T.Text
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'
foreign import ccall "soup_form_encode_datalist" soup_form_encode_datalist ::
Ptr GLib.Data.Data ->
IO CString
formEncodeDatalist ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.Data.Data
-> m T.Text
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'
foreign import ccall "soup_date_time_to_string" soup_date_time_to_string ::
Ptr GLib.DateTime.DateTime ->
CUInt ->
IO CString
dateTimeToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
GLib.DateTime.DateTime
-> Soup.Enums.DateFormat
-> m T.Text
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'
foreign import ccall "soup_date_time_new_from_http_string" soup_date_time_new_from_http_string ::
CString ->
IO (Ptr GLib.DateTime.DateTime)
dateTimeNewFromHttpString ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m (Maybe GLib.DateTime.DateTime)
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
foreign import ccall "soup_cookies_to_response" soup_cookies_to_response ::
Ptr (GSList (Ptr Soup.Cookie.Cookie)) ->
Ptr Soup.Message.Message ->
IO ()
cookiesToResponse ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
[Soup.Cookie.Cookie]
-> a
-> 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 ()
foreign import ccall "soup_cookies_to_request" soup_cookies_to_request ::
Ptr (GSList (Ptr Soup.Cookie.Cookie)) ->
Ptr Soup.Message.Message ->
IO ()
cookiesToRequest ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
[Soup.Cookie.Cookie]
-> a
-> 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 ()
foreign import ccall "soup_cookies_to_cookie_header" ::
Ptr (GSList (Ptr Soup.Cookie.Cookie)) ->
IO CString
cookiesToCookieHeader ::
(B.CallStack.HasCallStack, MonadIO m) =>
[Soup.Cookie.Cookie]
-> m T.Text
[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'
foreign import ccall "soup_cookies_from_response" soup_cookies_from_response ::
Ptr Soup.Message.Message ->
IO (Ptr (GSList (Ptr Soup.Cookie.Cookie)))
cookiesFromResponse ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> m [Soup.Cookie.Cookie]
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''
foreign import ccall "soup_cookies_from_request" soup_cookies_from_request ::
Ptr Soup.Message.Message ->
IO (Ptr (GSList (Ptr Soup.Cookie.Cookie)))
cookiesFromRequest ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> m [Soup.Cookie.Cookie]
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''
foreign import ccall "soup_check_version" soup_check_version ::
Word32 ->
Word32 ->
Word32 ->
IO CInt
checkVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
Word32
-> Word32
-> Word32
-> m Bool
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'