#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 ,
formEncodeDatalist ,
formEncodeHash ,
formRequestNewFromDatalist ,
formRequestNewFromHash ,
formRequestNewFromMultipart ,
getMajorVersion ,
getMicroVersion ,
getMinorVersion ,
headerContains ,
headerFreeParamList ,
headerGStringAppendParam ,
headerGStringAppendParamQuoted ,
headerParseList ,
headerParseParamList ,
headerParseParamListStrict ,
headerParseQualityList ,
headerParseSemiParamList ,
headerParseSemiParamListStrict ,
headersParse ,
headersParseRequest ,
headersParseResponse ,
headersParseStatusLine ,
httpErrorQuark ,
strCaseEqual ,
strCaseHash ,
tldDomainIsPublicSuffix ,
tldGetBaseDomain ,
valueArrayNew ,
websocketClientPrepareHandshake ,
websocketClientPrepareHandshakeWithExtensions,
websocketClientVerifyHandshake ,
websocketClientVerifyHandshakeWithExtensions,
websocketServerCheckHandshake ,
websocketServerCheckHandshakeWithExtensions,
websocketServerProcessHandshake ,
websocketServerProcessHandshakeWithExtensions,
xmlrpcBuildMethodCall ,
xmlrpcBuildMethodResponse ,
xmlrpcBuildRequest ,
xmlrpcBuildResponse ,
xmlrpcMessageNew ,
xmlrpcMessageSetResponse ,
xmlrpcParseMethodCall ,
xmlrpcParseMethodResponse ,
xmlrpcParseRequest ,
xmlrpcParseResponse ,
xmlrpcVariantGetDatetime ,
xmlrpcVariantNewDatetime ,
) 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.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GLib.Structs.Data as GLib.Data
import qualified GI.GLib.Structs.String as GLib.String
import qualified GI.GObject.Structs.TypeClass as GObject.TypeClass
import qualified GI.GObject.Structs.ValueArray as GObject.ValueArray
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.WebsocketExtension as Soup.WebsocketExtension
import {-# SOURCE #-} qualified GI.Soup.Structs.Cookie as Soup.Cookie
import {-# SOURCE #-} qualified GI.Soup.Structs.Date as Soup.Date
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders
import {-# SOURCE #-} qualified GI.Soup.Structs.Multipart as Soup.Multipart
import {-# SOURCE #-} qualified GI.Soup.Structs.XMLRPCParams as Soup.XMLRPCParams
foreign import ccall "soup_xmlrpc_variant_new_datetime" soup_xmlrpc_variant_new_datetime ::
Ptr Soup.Date.Date ->
IO (Ptr GVariant)
xmlrpcVariantNewDatetime ::
(B.CallStack.HasCallStack, MonadIO m) =>
Soup.Date.Date
-> m GVariant
xmlrpcVariantNewDatetime :: Date -> m GVariant
xmlrpcVariantNewDatetime Date
date = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
Ptr Date
date' <- Date -> IO (Ptr Date)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Date
date
Ptr GVariant
result <- Ptr Date -> IO (Ptr GVariant)
soup_xmlrpc_variant_new_datetime Ptr Date
date'
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xmlrpcVariantNewDatetime" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
Date -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Date
date
GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
foreign import ccall "soup_xmlrpc_variant_get_datetime" soup_xmlrpc_variant_get_datetime ::
Ptr GVariant ->
Ptr (Ptr GError) ->
IO (Ptr Soup.Date.Date)
xmlrpcVariantGetDatetime ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m Soup.Date.Date
xmlrpcVariantGetDatetime :: GVariant -> m Date
xmlrpcVariantGetDatetime GVariant
variant = IO Date -> m Date
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Date -> m Date) -> IO Date -> m Date
forall a b. (a -> b) -> a -> b
$ do
Ptr GVariant
variant' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
variant
IO Date -> IO () -> IO Date
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Date
result <- (Ptr (Ptr GError) -> IO (Ptr Date)) -> IO (Ptr Date)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Date)) -> IO (Ptr Date))
-> (Ptr (Ptr GError) -> IO (Ptr Date)) -> IO (Ptr Date)
forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> Ptr (Ptr GError) -> IO (Ptr Date)
soup_xmlrpc_variant_get_datetime Ptr GVariant
variant'
Text -> Ptr Date -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xmlrpcVariantGetDatetime" Ptr Date
result
Date
result' <- ((ManagedPtr Date -> Date) -> Ptr Date -> IO Date
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Date -> Date
Soup.Date.Date) Ptr Date
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
variant
Date -> IO Date
forall (m :: * -> *) a. Monad m => a -> m a
return Date
result'
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "soup_xmlrpc_parse_response" soup_xmlrpc_parse_response ::
CString ->
Int32 ->
CString ->
Ptr (Ptr GError) ->
IO (Ptr GVariant)
xmlrpcParseResponse ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int32
-> Maybe (T.Text)
-> m GVariant
xmlrpcParseResponse :: Text -> Int32 -> Maybe Text -> m GVariant
xmlrpcParseResponse Text
methodResponse Int32
length_ Maybe Text
signature = IO GVariant -> m GVariant
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GVariant -> m GVariant) -> IO GVariant -> m GVariant
forall a b. (a -> b) -> a -> b
$ do
CString
methodResponse' <- Text -> IO CString
textToCString Text
methodResponse
CString
maybeSignature <- case Maybe Text
signature of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jSignature -> do
CString
jSignature' <- Text -> IO CString
textToCString Text
jSignature
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jSignature'
IO GVariant -> IO () -> IO GVariant
forall a b. IO a -> IO b -> IO a
onException (do
Ptr GVariant
result <- (Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant))
-> (Ptr (Ptr GError) -> IO (Ptr GVariant)) -> IO (Ptr GVariant)
forall a b. (a -> b) -> a -> b
$ CString
-> Int32 -> CString -> Ptr (Ptr GError) -> IO (Ptr GVariant)
soup_xmlrpc_parse_response CString
methodResponse' Int32
length_ CString
maybeSignature
Text -> Ptr GVariant -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xmlrpcParseResponse" Ptr GVariant
result
GVariant
result' <- Ptr GVariant -> IO GVariant
B.GVariant.wrapGVariantPtr Ptr GVariant
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodResponse'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeSignature
GVariant -> IO GVariant
forall (m :: * -> *) a. Monad m => a -> m a
return GVariant
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodResponse'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeSignature
)
foreign import ccall "soup_xmlrpc_parse_request" soup_xmlrpc_parse_request ::
CString ->
Int32 ->
Ptr (Ptr Soup.XMLRPCParams.XMLRPCParams) ->
Ptr (Ptr GError) ->
IO CString
xmlrpcParseRequest ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int32
-> m ((T.Text, Soup.XMLRPCParams.XMLRPCParams))
xmlrpcParseRequest :: Text -> Int32 -> m (Text, XMLRPCParams)
xmlrpcParseRequest Text
methodCall Int32
length_ = IO (Text, XMLRPCParams) -> m (Text, XMLRPCParams)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, XMLRPCParams) -> m (Text, XMLRPCParams))
-> IO (Text, XMLRPCParams) -> m (Text, XMLRPCParams)
forall a b. (a -> b) -> a -> b
$ do
CString
methodCall' <- Text -> IO CString
textToCString Text
methodCall
Ptr (Ptr XMLRPCParams)
params <- IO (Ptr (Ptr XMLRPCParams))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr Soup.XMLRPCParams.XMLRPCParams))
IO (Text, XMLRPCParams) -> IO () -> IO (Text, XMLRPCParams)
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ CString
-> Int32
-> Ptr (Ptr XMLRPCParams)
-> Ptr (Ptr GError)
-> IO CString
soup_xmlrpc_parse_request CString
methodCall' Int32
length_ Ptr (Ptr XMLRPCParams)
params
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xmlrpcParseRequest" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Ptr XMLRPCParams
params' <- Ptr (Ptr XMLRPCParams) -> IO (Ptr XMLRPCParams)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr XMLRPCParams)
params
XMLRPCParams
params'' <- ((ManagedPtr XMLRPCParams -> XMLRPCParams)
-> Ptr XMLRPCParams -> IO XMLRPCParams
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr XMLRPCParams -> XMLRPCParams
Soup.XMLRPCParams.XMLRPCParams) Ptr XMLRPCParams
params'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodCall'
Ptr (Ptr XMLRPCParams) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr XMLRPCParams)
params
(Text, XMLRPCParams) -> IO (Text, XMLRPCParams)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
result', XMLRPCParams
params'')
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodCall'
Ptr (Ptr XMLRPCParams) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr XMLRPCParams)
params
)
foreign import ccall "soup_xmlrpc_parse_method_response" soup_xmlrpc_parse_method_response ::
CString ->
Int32 ->
Ptr GValue ->
Ptr (Ptr GError) ->
IO CInt
{-# DEPRECATED xmlrpcParseMethodResponse ["Use 'GI.Soup.Functions.xmlrpcParseResponse' instead."] #-}
xmlrpcParseMethodResponse ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int32
-> m (GValue)
xmlrpcParseMethodResponse :: Text -> Int32 -> m GValue
xmlrpcParseMethodResponse Text
methodResponse Int32
length_ = IO GValue -> m GValue
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GValue -> m GValue) -> IO GValue -> m GValue
forall a b. (a -> b) -> a -> b
$ do
CString
methodResponse' <- Text -> IO CString
textToCString Text
methodResponse
Ptr GValue
value <- Int -> IO (Ptr GValue)
forall a. Int -> IO (Ptr a)
SP.callocBytes Int
24 :: IO (Ptr GValue)
IO GValue -> IO () -> IO GValue
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
$ CString -> Int32 -> Ptr GValue -> Ptr (Ptr GError) -> IO CInt
soup_xmlrpc_parse_method_response CString
methodResponse' Int32
length_ Ptr GValue
value
GValue
value' <- Ptr GValue -> IO GValue
B.GValue.wrapGValuePtr Ptr GValue
value
Ptr GValue -> IO ()
B.GValue.unsetGValue Ptr GValue
value
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodResponse'
GValue -> IO GValue
forall (m :: * -> *) a. Monad m => a -> m a
return GValue
value'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodResponse'
Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
value
)
foreign import ccall "soup_xmlrpc_parse_method_call" soup_xmlrpc_parse_method_call ::
CString ->
Int32 ->
Ptr CString ->
Ptr (Ptr GObject.ValueArray.ValueArray) ->
IO CInt
{-# DEPRECATED xmlrpcParseMethodCall ["Use @/soup_xmlrpc_parse_request_full()/@ instead."] #-}
xmlrpcParseMethodCall ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Int32
-> m ((Bool, T.Text, GObject.ValueArray.ValueArray))
xmlrpcParseMethodCall :: Text -> Int32 -> m (Bool, Text, ValueArray)
xmlrpcParseMethodCall Text
methodCall Int32
length_ = IO (Bool, Text, ValueArray) -> m (Bool, Text, ValueArray)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text, ValueArray) -> m (Bool, Text, ValueArray))
-> IO (Bool, Text, ValueArray) -> m (Bool, Text, ValueArray)
forall a b. (a -> b) -> a -> b
$ do
CString
methodCall' <- Text -> IO CString
textToCString Text
methodCall
Ptr CString
methodName <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr (Ptr ValueArray)
params <- IO (Ptr (Ptr ValueArray))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GObject.ValueArray.ValueArray))
CInt
result <- CString -> Int32 -> Ptr CString -> Ptr (Ptr ValueArray) -> IO CInt
soup_xmlrpc_parse_method_call CString
methodCall' Int32
length_ Ptr CString
methodName Ptr (Ptr ValueArray)
params
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
methodName' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
methodName
Text
methodName'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
methodName'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodName'
Ptr ValueArray
params' <- Ptr (Ptr ValueArray) -> IO (Ptr ValueArray)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr ValueArray)
params
ValueArray
params'' <- ((ManagedPtr ValueArray -> ValueArray)
-> Ptr ValueArray -> IO ValueArray
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ValueArray -> ValueArray
GObject.ValueArray.ValueArray) Ptr ValueArray
params'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodCall'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
methodName
Ptr (Ptr ValueArray) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr ValueArray)
params
(Bool, Text, ValueArray) -> IO (Bool, Text, ValueArray)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
methodName'', ValueArray
params'')
foreign import ccall "soup_xmlrpc_message_set_response" soup_xmlrpc_message_set_response ::
Ptr Soup.Message.Message ->
Ptr GVariant ->
Ptr (Ptr GError) ->
IO CInt
xmlrpcMessageSetResponse ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> GVariant
-> m ()
xmlrpcMessageSetResponse :: a -> GVariant -> m ()
xmlrpcMessageSetResponse a
msg GVariant
value = IO () -> m ()
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 GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
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 Message -> Ptr GVariant -> Ptr (Ptr GError) -> IO CInt
soup_xmlrpc_message_set_response Ptr Message
msg' Ptr GVariant
value'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "soup_xmlrpc_message_new" soup_xmlrpc_message_new ::
CString ->
CString ->
Ptr GVariant ->
Ptr (Ptr GError) ->
IO (Ptr Soup.Message.Message)
xmlrpcMessageNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> GVariant
-> m Soup.Message.Message
xmlrpcMessageNew :: Text -> Text -> GVariant -> m Message
xmlrpcMessageNew Text
uri Text
methodName GVariant
params = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
CString
uri' <- Text -> IO CString
textToCString Text
uri
CString
methodName' <- Text -> IO CString
textToCString Text
methodName
Ptr GVariant
params' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
params
IO Message -> IO () -> IO Message
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Message
result <- (Ptr (Ptr GError) -> IO (Ptr Message)) -> IO (Ptr Message)
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr Message)) -> IO (Ptr Message))
-> (Ptr (Ptr GError) -> IO (Ptr Message)) -> IO (Ptr Message)
forall a b. (a -> b) -> a -> b
$ CString
-> CString -> Ptr GVariant -> Ptr (Ptr GError) -> IO (Ptr Message)
soup_xmlrpc_message_new CString
uri' CString
methodName' Ptr GVariant
params'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xmlrpcMessageNew" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
params
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodName'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodName'
)
foreign import ccall "soup_xmlrpc_build_response" soup_xmlrpc_build_response ::
Ptr GVariant ->
Ptr (Ptr GError) ->
IO CString
xmlrpcBuildResponse ::
(B.CallStack.HasCallStack, MonadIO m) =>
GVariant
-> m T.Text
xmlrpcBuildResponse :: GVariant -> m Text
xmlrpcBuildResponse GVariant
value = IO Text -> m Text
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 GVariant
value' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
value
IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ Ptr GVariant -> Ptr (Ptr GError) -> IO CString
soup_xmlrpc_build_response Ptr GVariant
value'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xmlrpcBuildResponse" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
value
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "soup_xmlrpc_build_request" soup_xmlrpc_build_request ::
CString ->
Ptr GVariant ->
Ptr (Ptr GError) ->
IO CString
xmlrpcBuildRequest ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> GVariant
-> m T.Text
xmlrpcBuildRequest :: Text -> GVariant -> m Text
xmlrpcBuildRequest Text
methodName GVariant
params = IO Text -> m Text
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
CString
methodName' <- Text -> IO CString
textToCString Text
methodName
Ptr GVariant
params' <- GVariant -> IO (Ptr GVariant)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GVariant
params
IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ CString -> Ptr GVariant -> Ptr (Ptr GError) -> IO CString
soup_xmlrpc_build_request CString
methodName' Ptr GVariant
params'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"xmlrpcBuildRequest" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
GVariant -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GVariant
params
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodName'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodName'
)
foreign import ccall "soup_xmlrpc_build_method_response" soup_xmlrpc_build_method_response ::
Ptr GValue ->
IO CString
{-# DEPRECATED xmlrpcBuildMethodResponse ["Use 'GI.Soup.Functions.xmlrpcBuildResponse' instead."] #-}
xmlrpcBuildMethodResponse ::
(B.CallStack.HasCallStack, MonadIO m) =>
GValue
-> m (Maybe T.Text)
xmlrpcBuildMethodResponse :: GValue -> m (Maybe Text)
xmlrpcBuildMethodResponse GValue
value = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr GValue
value' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
value
CString
result <- Ptr GValue -> IO CString
soup_xmlrpc_build_method_response Ptr GValue
value'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
value
Ptr GValue -> IO ()
B.GValue.unsetGValue Ptr GValue
value'
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "soup_xmlrpc_build_method_call" soup_xmlrpc_build_method_call ::
CString ->
Ptr B.GValue.GValue ->
Int32 ->
IO CString
{-# DEPRECATED xmlrpcBuildMethodCall ["Use 'GI.Soup.Functions.xmlrpcBuildRequest' instead."] #-}
xmlrpcBuildMethodCall ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> [GValue]
-> m (Maybe T.Text)
xmlrpcBuildMethodCall :: Text -> [GValue] -> m (Maybe Text)
xmlrpcBuildMethodCall Text
methodName [GValue]
params = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
let nParams :: Int32
nParams = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [GValue] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [GValue]
params
CString
methodName' <- Text -> IO CString
textToCString Text
methodName
Ptr GValue
params' <- [GValue] -> IO (Ptr GValue)
B.GValue.packGValueArray [GValue]
params
CString
result <- CString -> Ptr GValue -> Int32 -> IO CString
soup_xmlrpc_build_method_call CString
methodName' Ptr GValue
params' Int32
nParams
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
(GValue -> IO ()) -> [GValue] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [GValue]
params
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
methodName'
(Int32 -> (Ptr GValue -> IO ()) -> Ptr GValue -> IO ()
forall a c.
Integral a =>
a -> (Ptr GValue -> IO c) -> Ptr GValue -> IO ()
B.GValue.mapGValueArrayWithLength Int32
nParams) Ptr GValue -> IO ()
B.GValue.unsetGValue Ptr GValue
params'
Ptr GValue -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr GValue
params'
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "soup_websocket_server_process_handshake_with_extensions" soup_websocket_server_process_handshake_with_extensions ::
Ptr Soup.Message.Message ->
CString ->
Ptr CString ->
Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) ->
Ptr (Ptr (GList (Ptr Soup.WebsocketExtension.WebsocketExtension))) ->
IO CInt
websocketServerProcessHandshakeWithExtensions ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> Maybe ([GObject.TypeClass.TypeClass])
-> m ((Bool, [Soup.WebsocketExtension.WebsocketExtension]))
websocketServerProcessHandshakeWithExtensions :: a
-> Maybe Text
-> Maybe [Text]
-> Maybe [TypeClass]
-> m (Bool, [WebsocketExtension])
websocketServerProcessHandshakeWithExtensions a
msg Maybe Text
expectedOrigin Maybe [Text]
protocols Maybe [TypeClass]
supportedExtensions = IO (Bool, [WebsocketExtension]) -> m (Bool, [WebsocketExtension])
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 Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
CString
maybeExpectedOrigin <- case Maybe Text
expectedOrigin of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jExpectedOrigin -> do
CString
jExpectedOrigin' <- Text -> IO CString
textToCString Text
jExpectedOrigin
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedOrigin'
Ptr CString
maybeProtocols <- case Maybe [Text]
protocols of
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just [Text]
jProtocols -> do
Ptr CString
jProtocols' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jProtocols
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jProtocols'
Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions <- case Maybe [TypeClass]
supportedExtensions of
Maybe [TypeClass]
Nothing -> Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
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)
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 (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 Message
-> CString
-> Ptr CString
-> Ptr (GPtrArray (Ptr TypeClass))
-> Ptr (Ptr (GList (Ptr WebsocketExtension)))
-> IO CInt
soup_websocket_server_process_handshake_with_extensions Ptr Message
msg' CString
maybeExpectedOrigin Ptr CString
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)
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)
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedOrigin
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
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 (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', [WebsocketExtension]
acceptedExtensions''')
foreign import ccall "soup_websocket_server_process_handshake" soup_websocket_server_process_handshake ::
Ptr Soup.Message.Message ->
CString ->
Ptr CString ->
IO CInt
websocketServerProcessHandshake ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> m Bool
websocketServerProcessHandshake :: a -> Maybe Text -> Maybe [Text] -> m Bool
websocketServerProcessHandshake a
msg Maybe Text
expectedOrigin Maybe [Text]
protocols = IO Bool -> m Bool
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 Message
msg' <- a -> IO (Ptr Message)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
CString
maybeExpectedOrigin <- case Maybe Text
expectedOrigin of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jExpectedOrigin -> do
CString
jExpectedOrigin' <- Text -> IO CString
textToCString Text
jExpectedOrigin
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jExpectedOrigin'
Ptr CString
maybeProtocols <- case Maybe [Text]
protocols of
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just [Text]
jProtocols -> do
Ptr CString
jProtocols' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jProtocols
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jProtocols'
CInt
result <- Ptr Message -> CString -> Ptr CString -> IO CInt
soup_websocket_server_process_handshake Ptr Message
msg' CString
maybeExpectedOrigin Ptr CString
maybeProtocols
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeExpectedOrigin
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "soup_websocket_server_check_handshake_with_extensions" soup_websocket_server_check_handshake_with_extensions ::
Ptr Soup.Message.Message ->
CString ->
Ptr CString ->
Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) ->
Ptr (Ptr GError) ->
IO CInt
websocketServerCheckHandshakeWithExtensions ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> Maybe ([GObject.TypeClass.TypeClass])
-> m ()
websocketServerCheckHandshakeWithExtensions :: a -> Maybe Text -> Maybe [Text] -> Maybe [TypeClass] -> m ()
websocketServerCheckHandshakeWithExtensions a
msg Maybe Text
origin Maybe [Text]
protocols Maybe [TypeClass]
supportedExtensions = IO () -> m ()
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
CString
maybeOrigin <- case Maybe Text
origin of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jOrigin -> do
CString
jOrigin' <- Text -> IO CString
textToCString Text
jOrigin
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOrigin'
Ptr CString
maybeProtocols <- case Maybe [Text]
protocols of
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just [Text]
jProtocols -> do
Ptr CString
jProtocols' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jProtocols
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jProtocols'
Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions <- case Maybe [TypeClass]
supportedExtensions of
Maybe [TypeClass]
Nothing -> Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
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)
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 (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 Message
-> CString
-> Ptr CString
-> Ptr (GPtrArray (Ptr TypeClass))
-> Ptr (Ptr GError)
-> IO CInt
soup_websocket_server_check_handshake_with_extensions Ptr Message
msg' CString
maybeOrigin Ptr CString
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)
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOrigin
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOrigin
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
)
foreign import ccall "soup_websocket_server_check_handshake" soup_websocket_server_check_handshake ::
Ptr Soup.Message.Message ->
CString ->
Ptr CString ->
Ptr (Ptr GError) ->
IO CInt
websocketServerCheckHandshake ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> m ()
websocketServerCheckHandshake :: a -> Maybe Text -> Maybe [Text] -> m ()
websocketServerCheckHandshake a
msg Maybe Text
origin Maybe [Text]
protocols = IO () -> m ()
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
CString
maybeOrigin <- case Maybe Text
origin of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jOrigin -> do
CString
jOrigin' <- Text -> IO CString
textToCString Text
jOrigin
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOrigin'
Ptr CString
maybeProtocols <- case Maybe [Text]
protocols of
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just [Text]
jProtocols -> do
Ptr CString
jProtocols' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jProtocols
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jProtocols'
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 Message
-> CString -> Ptr CString -> Ptr (Ptr GError) -> IO CInt
soup_websocket_server_check_handshake Ptr Message
msg' CString
maybeOrigin Ptr CString
maybeProtocols
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOrigin
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOrigin
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
)
foreign import ccall "soup_websocket_client_verify_handshake_with_extensions" soup_websocket_client_verify_handshake_with_extensions ::
Ptr Soup.Message.Message ->
Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) ->
Ptr (Ptr (GList (Ptr Soup.WebsocketExtension.WebsocketExtension))) ->
Ptr (Ptr GError) ->
IO CInt
websocketClientVerifyHandshakeWithExtensions ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe ([GObject.TypeClass.TypeClass])
-> m ([Soup.WebsocketExtension.WebsocketExtension])
websocketClientVerifyHandshakeWithExtensions :: a -> Maybe [TypeClass] -> m [WebsocketExtension]
websocketClientVerifyHandshakeWithExtensions a
msg Maybe [TypeClass]
supportedExtensions = IO [WebsocketExtension] -> m [WebsocketExtension]
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 (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)
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 (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_with_extensions 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)
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 (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_verify_handshake" soup_websocket_client_verify_handshake ::
Ptr Soup.Message.Message ->
Ptr (Ptr GError) ->
IO CInt
websocketClientVerifyHandshake ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> m ()
websocketClientVerifyHandshake :: a -> m ()
websocketClientVerifyHandshake a
msg = IO () -> m ()
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
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 Message -> Ptr (Ptr GError) -> IO CInt
soup_websocket_client_verify_handshake Ptr Message
msg'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "soup_websocket_client_prepare_handshake_with_extensions" soup_websocket_client_prepare_handshake_with_extensions ::
Ptr Soup.Message.Message ->
CString ->
Ptr CString ->
Ptr (GPtrArray (Ptr GObject.TypeClass.TypeClass)) ->
IO ()
websocketClientPrepareHandshakeWithExtensions ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> Maybe ([GObject.TypeClass.TypeClass])
-> m ()
websocketClientPrepareHandshakeWithExtensions :: a -> Maybe Text -> Maybe [Text] -> Maybe [TypeClass] -> m ()
websocketClientPrepareHandshakeWithExtensions a
msg Maybe Text
origin Maybe [Text]
protocols Maybe [TypeClass]
supportedExtensions = IO () -> m ()
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
CString
maybeOrigin <- case Maybe Text
origin of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jOrigin -> do
CString
jOrigin' <- Text -> IO CString
textToCString Text
jOrigin
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOrigin'
Ptr CString
maybeProtocols <- case Maybe [Text]
protocols of
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just [Text]
jProtocols -> do
Ptr CString
jProtocols' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jProtocols
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jProtocols'
Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions <- case Maybe [TypeClass]
supportedExtensions of
Maybe [TypeClass]
Nothing -> Ptr (GPtrArray (Ptr TypeClass))
-> IO (Ptr (GPtrArray (Ptr TypeClass)))
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)
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 (m :: * -> *) a. Monad m => a -> m a
return Ptr (GPtrArray (Ptr TypeClass))
jSupportedExtensions''
Ptr Message
-> CString
-> Ptr CString
-> Ptr (GPtrArray (Ptr TypeClass))
-> IO ()
soup_websocket_client_prepare_handshake_with_extensions Ptr Message
msg' CString
maybeOrigin Ptr CString
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)
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOrigin
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr (GPtrArray (Ptr TypeClass)) -> IO ()
forall a. Ptr (GPtrArray a) -> IO ()
unrefPtrArray Ptr (GPtrArray (Ptr TypeClass))
maybeSupportedExtensions
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "soup_websocket_client_prepare_handshake" soup_websocket_client_prepare_handshake ::
Ptr Soup.Message.Message ->
CString ->
Ptr CString ->
IO ()
websocketClientPrepareHandshake ::
(B.CallStack.HasCallStack, MonadIO m, Soup.Message.IsMessage a) =>
a
-> Maybe (T.Text)
-> Maybe ([T.Text])
-> m ()
websocketClientPrepareHandshake :: a -> Maybe Text -> Maybe [Text] -> m ()
websocketClientPrepareHandshake a
msg Maybe Text
origin Maybe [Text]
protocols = IO () -> m ()
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
CString
maybeOrigin <- case Maybe Text
origin of
Maybe Text
Nothing -> CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
Just Text
jOrigin -> do
CString
jOrigin' <- Text -> IO CString
textToCString Text
jOrigin
CString -> IO CString
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jOrigin'
Ptr CString
maybeProtocols <- case Maybe [Text]
protocols of
Maybe [Text]
Nothing -> Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
forall a. Ptr a
nullPtr
Just [Text]
jProtocols -> do
Ptr CString
jProtocols' <- [Text] -> IO (Ptr CString)
packZeroTerminatedUTF8CArray [Text]
jProtocols
Ptr CString -> IO (Ptr CString)
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr CString
jProtocols'
Ptr Message -> CString -> Ptr CString -> IO ()
soup_websocket_client_prepare_handshake Ptr Message
msg' CString
maybeOrigin Ptr CString
maybeProtocols
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeOrigin
(CString -> IO ()) -> Ptr CString -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (Ptr a) -> IO ()
mapZeroTerminatedCArray CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
maybeProtocols
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "soup_value_array_new" soup_value_array_new ::
IO (Ptr GObject.ValueArray.ValueArray)
{-# DEPRECATED valueArrayNew ["Use t'GVariant' API instead."] #-}
valueArrayNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
m GObject.ValueArray.ValueArray
valueArrayNew :: m ValueArray
valueArrayNew = IO ValueArray -> m ValueArray
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ValueArray -> m ValueArray) -> IO ValueArray -> m ValueArray
forall a b. (a -> b) -> a -> b
$ do
Ptr ValueArray
result <- IO (Ptr ValueArray)
soup_value_array_new
Text -> Ptr ValueArray -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"valueArrayNew" Ptr ValueArray
result
ValueArray
result' <- ((ManagedPtr ValueArray -> ValueArray)
-> Ptr ValueArray -> IO ValueArray
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr ValueArray -> ValueArray
GObject.ValueArray.ValueArray) Ptr ValueArray
result
ValueArray -> IO ValueArray
forall (m :: * -> *) a. Monad m => a -> m a
return ValueArray
result'
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 :: Text -> m Text
tldGetBaseDomain Text
hostname = IO Text -> m Text
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
CString
hostname' <- Text -> IO CString
textToCString Text
hostname
IO Text -> IO () -> IO Text
forall a b. IO a -> IO b -> IO a
onException (do
CString
result <- (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CString) -> IO CString)
-> (Ptr (Ptr GError) -> IO CString) -> IO CString
forall a b. (a -> b) -> a -> b
$ CString -> Ptr (Ptr GError) -> IO CString
soup_tld_get_base_domain CString
hostname'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"tldGetBaseDomain" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
hostname'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
) (do
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
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 :: Text -> m Bool
tldDomainIsPublicSuffix Text
domain = IO Bool -> m Bool
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
CString
domain' <- Text -> IO CString
textToCString Text
domain
CInt
result <- CString -> IO CInt
soup_tld_domain_is_public_suffix CString
domain'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
domain'
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "soup_str_case_hash" soup_str_case_hash ::
Ptr () ->
IO Word32
strCaseHash ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> m Word32
strCaseHash :: Ptr () -> m Word32
strCaseHash Ptr ()
key = IO Word32 -> m Word32
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 <- Ptr () -> IO Word32
soup_str_case_hash Ptr ()
key
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "soup_str_case_equal" soup_str_case_equal ::
Ptr () ->
Ptr () ->
IO CInt
strCaseEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
Ptr ()
-> Ptr ()
-> m Bool
strCaseEqual :: Ptr () -> Ptr () -> m Bool
strCaseEqual Ptr ()
v1 Ptr ()
v2 = IO Bool -> m Bool
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 <- Ptr () -> Ptr () -> IO CInt
soup_str_case_equal Ptr ()
v1 Ptr ()
v2
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "soup_http_error_quark" soup_http_error_quark ::
IO Word32
httpErrorQuark ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
httpErrorQuark :: m Word32
httpErrorQuark = IO Word32 -> m Word32
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_http_error_quark
Word32 -> IO Word32
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
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 (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
CString
statusLine' <- Text -> IO CString
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 CString
reasonPhrase <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- CString -> Ptr CUInt -> Ptr Word32 -> Ptr CString -> IO CInt
soup_headers_parse_status_line CString
statusLine' Ptr CUInt
ver Ptr Word32
statusCode Ptr CString
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
CString
reasonPhrase' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
reasonPhrase
Text
reasonPhrase'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
reasonPhrase'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
reasonPhrase'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
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 CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
reasonPhrase
(Bool, HTTPVersion, Word32, Text)
-> IO (Bool, HTTPVersion, Word32, Text)
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 (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
CString
str' <- Text -> IO CString
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 CString
reasonPhrase <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- CString
-> Int32
-> Ptr MessageHeaders
-> Ptr CUInt
-> Ptr Word32
-> Ptr CString
-> IO CInt
soup_headers_parse_response CString
str' Int32
len Ptr MessageHeaders
headers' Ptr CUInt
ver Ptr Word32
statusCode Ptr CString
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
CString
reasonPhrase' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
reasonPhrase
Text
reasonPhrase'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
reasonPhrase'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
reasonPhrase'
MessageHeaders -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr MessageHeaders
headers
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
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 CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
reasonPhrase
(Bool, HTTPVersion, Word32, Text)
-> IO (Bool, HTTPVersion, Word32, Text)
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 (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
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr MessageHeaders
reqHeaders' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
reqHeaders
Ptr CString
reqMethod <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
reqPath <- IO (Ptr CString)
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 <- CString
-> Int32
-> Ptr MessageHeaders
-> Ptr CString
-> Ptr CString
-> Ptr CUInt
-> IO Word32
soup_headers_parse_request CString
str' Int32
len Ptr MessageHeaders
reqHeaders' Ptr CString
reqMethod Ptr CString
reqPath Ptr CUInt
ver
CString
reqMethod' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
reqMethod
Text
reqMethod'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
reqMethod'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
reqMethod'
CString
reqPath' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
reqPath
Text
reqPath'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
reqPath'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
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
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
reqMethod
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
reqPath
Ptr CUInt -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CUInt
ver
(Word32, Text, Text, HTTPVersion)
-> IO (Word32, Text, Text, HTTPVersion)
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 (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
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr MessageHeaders
dest' <- MessageHeaders -> IO (Ptr MessageHeaders)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr MessageHeaders
dest
CInt
result <- CString -> Int32 -> Ptr MessageHeaders -> IO CInt
soup_headers_parse CString
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
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
Bool -> IO Bool
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 (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
CString
header' <- Text -> IO CString
textToCString Text
header
Ptr (GHashTable CString CString)
result <- CString -> IO (Ptr (GHashTable CString CString))
soup_header_parse_semi_param_list_strict CString
header'
Maybe (Map Text Text)
maybeResult <- Ptr (GHashTable CString CString)
-> (Ptr (GHashTable CString CString) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GHashTable CString CString)
result ((Ptr (GHashTable CString CString) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text)))
-> (Ptr (GHashTable CString CString) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ \Ptr (GHashTable CString CString)
result' -> do
[(PtrWrapped CString, PtrWrapped CString)]
result'' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
result'
let result''' :: [(CString, PtrWrapped CString)]
result''' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
result''
[(Text, PtrWrapped CString)]
result'''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
result'''
let result''''' :: [(Text, CString)]
result''''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
cstringUnpackPtr [(Text, PtrWrapped CString)]
result''''
[(Text, Text)]
result'''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
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 CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
result'
Map Text Text -> IO (Map Text Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result'''''''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
header'
Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
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 (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
CString
header' <- Text -> IO CString
textToCString Text
header
Ptr (GHashTable CString CString)
result <- CString -> IO (Ptr (GHashTable CString CString))
soup_header_parse_semi_param_list CString
header'
Text -> Ptr (GHashTable CString CString) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"headerParseSemiParamList" Ptr (GHashTable CString CString)
result
[(PtrWrapped CString, PtrWrapped CString)]
result' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
result
let result'' :: [(CString, PtrWrapped CString)]
result'' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
result'
[(Text, PtrWrapped CString)]
result''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
result''
let result'''' :: [(Text, CString)]
result'''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
cstringUnpackPtr [(Text, PtrWrapped CString)]
result'''
[(Text, Text)]
result''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
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 CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
header'
Map Text Text -> IO (Map Text Text)
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 (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
CString
header' <- Text -> IO CString
textToCString Text
header
Ptr (Ptr (GSList CString))
unacceptable <- IO (Ptr (Ptr (GSList CString)))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr (GSList CString)))
Ptr (GSList CString)
result <- CString -> Ptr (Ptr (GSList CString)) -> IO (Ptr (GSList CString))
soup_header_parse_quality_list CString
header' Ptr (Ptr (GSList CString))
unacceptable
[CString]
result' <- Ptr (GSList CString) -> IO [CString]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList CString)
result
[Text]
result'' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
result'
(CString -> IO ()) -> Ptr (GSList CString) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()
mapGSList CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GSList CString)
result
Ptr (GSList CString) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList CString)
result
Ptr (GSList CString)
unacceptable' <- Ptr (Ptr (GSList CString)) -> IO (Ptr (GSList CString))
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr (GSList CString))
unacceptable
[CString]
unacceptable'' <- Ptr (GSList CString) -> IO [CString]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList CString)
unacceptable'
[Text]
unacceptable''' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
unacceptable''
(CString -> IO ()) -> Ptr (GSList CString) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()
mapGSList CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GSList CString)
unacceptable'
Ptr (GSList CString) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList CString)
unacceptable'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
header'
Ptr (Ptr (GSList CString)) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr (GSList CString))
unacceptable
([Text], [Text]) -> IO ([Text], [Text])
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 (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
CString
header' <- Text -> IO CString
textToCString Text
header
Ptr (GHashTable CString CString)
result <- CString -> IO (Ptr (GHashTable CString CString))
soup_header_parse_param_list_strict CString
header'
Maybe (Map Text Text)
maybeResult <- Ptr (GHashTable CString CString)
-> (Ptr (GHashTable CString CString) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr (GHashTable CString CString)
result ((Ptr (GHashTable CString CString) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text)))
-> (Ptr (GHashTable CString CString) -> IO (Map Text Text))
-> IO (Maybe (Map Text Text))
forall a b. (a -> b) -> a -> b
$ \Ptr (GHashTable CString CString)
result' -> do
[(PtrWrapped CString, PtrWrapped CString)]
result'' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
result'
let result''' :: [(CString, PtrWrapped CString)]
result''' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
result''
[(Text, PtrWrapped CString)]
result'''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
result'''
let result''''' :: [(Text, CString)]
result''''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
cstringUnpackPtr [(Text, PtrWrapped CString)]
result''''
[(Text, Text)]
result'''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
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 CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
result'
Map Text Text -> IO (Map Text Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Map Text Text
result'''''''
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
header'
Maybe (Map Text Text) -> IO (Maybe (Map Text Text))
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 (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
CString
header' <- Text -> IO CString
textToCString Text
header
Ptr (GHashTable CString CString)
result <- CString -> IO (Ptr (GHashTable CString CString))
soup_header_parse_param_list CString
header'
Text -> Ptr (GHashTable CString CString) -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"headerParseParamList" Ptr (GHashTable CString CString)
result
[(PtrWrapped CString, PtrWrapped CString)]
result' <- Ptr (GHashTable CString CString)
-> IO [(PtrWrapped CString, PtrWrapped CString)]
forall a b.
Ptr (GHashTable a b) -> IO [(PtrWrapped a, PtrWrapped b)]
unpackGHashTable Ptr (GHashTable CString CString)
result
let result'' :: [(CString, PtrWrapped CString)]
result'' = (PtrWrapped CString -> CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> [(CString, PtrWrapped CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst PtrWrapped CString -> CString
cstringUnpackPtr [(PtrWrapped CString, PtrWrapped CString)]
result'
[(Text, PtrWrapped CString)]
result''' <- (CString -> IO Text)
-> [(CString, PtrWrapped CString)]
-> IO [(Text, PtrWrapped CString)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(CString, PtrWrapped CString)]
result''
let result'''' :: [(Text, CString)]
result'''' = (PtrWrapped CString -> CString)
-> [(Text, PtrWrapped CString)] -> [(Text, CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond PtrWrapped CString -> CString
cstringUnpackPtr [(Text, PtrWrapped CString)]
result'''
[(Text, Text)]
result''''' <- (CString -> IO Text) -> [(Text, CString)] -> IO [(Text, Text)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [(Text, CString)]
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 CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
header'
Map Text Text -> IO (Map Text Text)
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 (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
CString
header' <- Text -> IO CString
textToCString Text
header
Ptr (GSList CString)
result <- CString -> IO (Ptr (GSList CString))
soup_header_parse_list CString
header'
[CString]
result' <- Ptr (GSList CString) -> IO [CString]
forall a. Ptr (GSList (Ptr a)) -> IO [Ptr a]
unpackGSList Ptr (GSList CString)
result
[Text]
result'' <- (CString -> IO Text) -> [CString] -> IO [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText [CString]
result'
(CString -> IO ()) -> Ptr (GSList CString) -> IO ()
forall a b. (Ptr a -> IO b) -> Ptr (GSList (Ptr a)) -> IO ()
mapGSList CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (GSList CString)
result
Ptr (GSList CString) -> IO ()
forall a. Ptr (GSList a) -> IO ()
g_slist_free Ptr (GSList CString)
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
header'
[Text] -> IO [Text]
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 (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
CString
name' <- Text -> IO CString
textToCString Text
name
CString
value' <- Text -> IO CString
textToCString Text
value
Ptr String -> CString -> CString -> IO ()
soup_header_g_string_append_param_quoted Ptr String
string' CString
name' CString
value'
String -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
() -> IO ()
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
-> T.Text
-> m ()
String
string Text
name Text
value = IO () -> m ()
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
CString
name' <- Text -> IO CString
textToCString Text
name
CString
value' <- Text -> IO CString
textToCString Text
value
Ptr String -> CString -> CString -> IO ()
soup_header_g_string_append_param Ptr String
string' CString
name' CString
value'
String -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
string
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
() -> IO ()
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 (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
[(CString, Text)]
paramList'' <- (Text -> IO CString) -> [(Text, Text)] -> IO [(CString, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO CString
textToCString [(Text, Text)]
paramList'
[(CString, CString)]
paramList''' <- (Text -> IO CString)
-> [(CString, Text)] -> IO [(CString, CString)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO CString
textToCString [(CString, Text)]
paramList''
let paramList'''' :: [(PtrWrapped CString, CString)]
paramList'''' = (CString -> PtrWrapped CString)
-> [(CString, CString)] -> [(PtrWrapped CString, CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst CString -> PtrWrapped CString
cstringPackPtr [(CString, CString)]
paramList'''
let paramList''''' :: [(PtrWrapped CString, PtrWrapped CString)]
paramList''''' = (CString -> PtrWrapped CString)
-> [(PtrWrapped CString, CString)]
-> [(PtrWrapped CString, PtrWrapped CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond CString -> PtrWrapped CString
cstringPackPtr [(PtrWrapped CString, CString)]
paramList''''
Ptr (GHashTable CString CString)
paramList'''''' <- GHashFunc CString
-> GEqualFunc CString
-> Maybe (GDestroyNotify CString)
-> Maybe (GDestroyNotify CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> IO (Ptr (GHashTable CString CString))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc CString
gStrHash GEqualFunc CString
gStrEqual (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped CString, PtrWrapped CString)]
paramList'''''
Ptr (GHashTable CString CString) -> IO ()
soup_header_free_param_list Ptr (GHashTable CString CString)
paramList''''''
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
paramList''''''
() -> IO ()
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 (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
CString
header' <- Text -> IO CString
textToCString Text
header
CString
token' <- Text -> IO CString
textToCString Text
token
CInt
result <- CString -> CString -> IO CInt
soup_header_contains CString
header' CString
token'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
header'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
token'
Bool -> IO Bool
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 :: m Word32
getMinorVersion = IO Word32 -> m Word32
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 (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 :: m Word32
getMicroVersion = IO Word32 -> m Word32
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 (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 :: m Word32
getMajorVersion = IO Word32 -> m Word32
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 (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "soup_form_request_new_from_multipart" soup_form_request_new_from_multipart ::
CString ->
Ptr Soup.Multipart.Multipart ->
IO (Ptr Soup.Message.Message)
formRequestNewFromMultipart ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Soup.Multipart.Multipart
-> m Soup.Message.Message
formRequestNewFromMultipart :: Text -> Multipart -> m Message
formRequestNewFromMultipart Text
uri Multipart
multipart = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
CString
uri' <- Text -> IO CString
textToCString Text
uri
Ptr Multipart
multipart' <- Multipart -> IO (Ptr Multipart)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Multipart
multipart
Ptr Message
result <- CString -> Ptr Multipart -> IO (Ptr Message)
soup_form_request_new_from_multipart CString
uri' Ptr Multipart
multipart'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"formRequestNewFromMultipart" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
result
Multipart -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Multipart
multipart
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
foreign import ccall "soup_form_request_new_from_hash" soup_form_request_new_from_hash ::
CString ->
CString ->
Ptr (GHashTable CString CString) ->
IO (Ptr Soup.Message.Message)
formRequestNewFromHash ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> Map.Map T.Text T.Text
-> m Soup.Message.Message
formRequestNewFromHash :: Text -> Text -> Map Text Text -> m Message
formRequestNewFromHash Text
method Text
uri Map Text Text
formDataSet = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
CString
method' <- Text -> IO CString
textToCString Text
method
CString
uri' <- Text -> IO CString
textToCString Text
uri
let formDataSet' :: [(Text, Text)]
formDataSet' = Map Text Text -> [(Text, Text)]
forall k a. Map k a -> [(k, a)]
Map.toList Map Text Text
formDataSet
[(CString, Text)]
formDataSet'' <- (Text -> IO CString) -> [(Text, Text)] -> IO [(CString, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO CString
textToCString [(Text, Text)]
formDataSet'
[(CString, CString)]
formDataSet''' <- (Text -> IO CString)
-> [(CString, Text)] -> IO [(CString, CString)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO CString
textToCString [(CString, Text)]
formDataSet''
let formDataSet'''' :: [(PtrWrapped CString, CString)]
formDataSet'''' = (CString -> PtrWrapped CString)
-> [(CString, CString)] -> [(PtrWrapped CString, CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst CString -> PtrWrapped CString
cstringPackPtr [(CString, CString)]
formDataSet'''
let formDataSet''''' :: [(PtrWrapped CString, PtrWrapped CString)]
formDataSet''''' = (CString -> PtrWrapped CString)
-> [(PtrWrapped CString, CString)]
-> [(PtrWrapped CString, PtrWrapped CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond CString -> PtrWrapped CString
cstringPackPtr [(PtrWrapped CString, CString)]
formDataSet''''
Ptr (GHashTable CString CString)
formDataSet'''''' <- GHashFunc CString
-> GEqualFunc CString
-> Maybe (GDestroyNotify CString)
-> Maybe (GDestroyNotify CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> IO (Ptr (GHashTable CString CString))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc CString
gStrHash GEqualFunc CString
gStrEqual (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped CString, PtrWrapped CString)]
formDataSet'''''
Ptr Message
result <- CString
-> CString -> Ptr (GHashTable CString CString) -> IO (Ptr Message)
soup_form_request_new_from_hash CString
method' CString
uri' Ptr (GHashTable CString CString)
formDataSet''''''
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"formRequestNewFromHash" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
method'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
formDataSet''''''
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
result'
foreign import ccall "soup_form_request_new_from_datalist" soup_form_request_new_from_datalist ::
CString ->
CString ->
Ptr GLib.Data.Data ->
IO (Ptr Soup.Message.Message)
formRequestNewFromDatalist ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> GLib.Data.Data
-> m Soup.Message.Message
formRequestNewFromDatalist :: Text -> Text -> Data -> m Message
formRequestNewFromDatalist Text
method Text
uri Data
formDataSet = IO Message -> m Message
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Message -> m Message) -> IO Message -> m Message
forall a b. (a -> b) -> a -> b
$ do
CString
method' <- Text -> IO CString
textToCString Text
method
CString
uri' <- Text -> IO CString
textToCString Text
uri
Ptr Data
formDataSet' <- Data -> IO (Ptr Data)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Data
formDataSet
Ptr Message
result <- CString -> CString -> Ptr Data -> IO (Ptr Message)
soup_form_request_new_from_datalist CString
method' CString
uri' Ptr Data
formDataSet'
Text -> Ptr Message -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"formRequestNewFromDatalist" Ptr Message
result
Message
result' <- ((ManagedPtr Message -> Message) -> Ptr Message -> IO Message
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Message -> Message
Soup.Message.Message) Ptr Message
result
Data -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Data
formDataSet
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
method'
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
Message -> IO Message
forall (m :: * -> *) a. Monad m => a -> m a
return Message
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 :: Map Text Text -> m Text
formEncodeHash Map Text Text
formDataSet = IO Text -> m Text
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
[(CString, Text)]
formDataSet'' <- (Text -> IO CString) -> [(Text, Text)] -> IO [(CString, Text)]
forall (f :: * -> *) a c b.
Applicative f =>
(a -> f c) -> [(a, b)] -> f [(c, b)]
mapFirstA Text -> IO CString
textToCString [(Text, Text)]
formDataSet'
[(CString, CString)]
formDataSet''' <- (Text -> IO CString)
-> [(CString, Text)] -> IO [(CString, CString)]
forall (f :: * -> *) b c a.
Applicative f =>
(b -> f c) -> [(a, b)] -> f [(a, c)]
mapSecondA Text -> IO CString
textToCString [(CString, Text)]
formDataSet''
let formDataSet'''' :: [(PtrWrapped CString, CString)]
formDataSet'''' = (CString -> PtrWrapped CString)
-> [(CString, CString)] -> [(PtrWrapped CString, CString)]
forall a c b. (a -> c) -> [(a, b)] -> [(c, b)]
mapFirst CString -> PtrWrapped CString
cstringPackPtr [(CString, CString)]
formDataSet'''
let formDataSet''''' :: [(PtrWrapped CString, PtrWrapped CString)]
formDataSet''''' = (CString -> PtrWrapped CString)
-> [(PtrWrapped CString, CString)]
-> [(PtrWrapped CString, PtrWrapped CString)]
forall b c a. (b -> c) -> [(a, b)] -> [(a, c)]
mapSecond CString -> PtrWrapped CString
cstringPackPtr [(PtrWrapped CString, CString)]
formDataSet''''
Ptr (GHashTable CString CString)
formDataSet'''''' <- GHashFunc CString
-> GEqualFunc CString
-> Maybe (GDestroyNotify CString)
-> Maybe (GDestroyNotify CString)
-> [(PtrWrapped CString, PtrWrapped CString)]
-> IO (Ptr (GHashTable CString CString))
forall a b.
GHashFunc a
-> GEqualFunc a
-> Maybe (GDestroyNotify a)
-> Maybe (GDestroyNotify b)
-> [(PtrWrapped a, PtrWrapped b)]
-> IO (Ptr (GHashTable a b))
packGHashTable GHashFunc CString
gStrHash GEqualFunc CString
gStrEqual (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) (GDestroyNotify CString -> Maybe (GDestroyNotify CString)
forall a. a -> Maybe a
Just GDestroyNotify CString
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free) [(PtrWrapped CString, PtrWrapped CString)]
formDataSet'''''
CString
result <- Ptr (GHashTable CString CString) -> IO CString
soup_form_encode_hash Ptr (GHashTable CString CString)
formDataSet''''''
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"formEncodeHash" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Ptr (GHashTable CString CString) -> IO ()
forall a b. Ptr (GHashTable a b) -> IO ()
unrefGHashTable Ptr (GHashTable CString CString)
formDataSet''''''
Text -> IO Text
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 :: Data -> m Text
formEncodeDatalist Data
formDataSet = IO Text -> m Text
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
CString
result <- Ptr Data -> IO CString
soup_form_encode_datalist Ptr Data
formDataSet'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"formEncodeDatalist" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result
Data -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Data
formDataSet
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
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 :: [Cookie] -> a -> m ()
cookiesToResponse [Cookie]
cookies a
msg = IO () -> m ()
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)
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 (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 :: [Cookie] -> a -> m ()
cookiesToRequest [Cookie]
cookies a
msg = IO () -> m ()
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)
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 (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 (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)
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'
CString
result <- Ptr (GSList (Ptr Cookie)) -> IO CString
soup_cookies_to_cookie_header Ptr (GSList (Ptr Cookie))
cookies''
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"cookiesToCookieHeader" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
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 (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 :: a -> m [Cookie]
cookiesFromResponse a
msg = IO [Cookie] -> m [Cookie]
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)
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 (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 :: a -> m [Cookie]
cookiesFromRequest a
msg = IO [Cookie] -> m [Cookie]
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)
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 (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 :: Word32 -> Word32 -> Word32 -> m Bool
checkVersion Word32
major Word32
minor Word32
micro = IO Bool -> m Bool
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 (m :: * -> *) a. Monad m => a -> m a
return Bool
result'