#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Soup.Objects.Message
(
Message(..) ,
IsMessage ,
toMessage ,
noMessage ,
#if ENABLE_OVERLOADING
MessageContentSniffedMethodInfo ,
#endif
messageContentSniffed ,
#if ENABLE_OVERLOADING
MessageDisableFeatureMethodInfo ,
#endif
messageDisableFeature ,
#if ENABLE_OVERLOADING
MessageFinishedMethodInfo ,
#endif
messageFinished ,
#if ENABLE_OVERLOADING
MessageGetAddressMethodInfo ,
#endif
messageGetAddress ,
#if ENABLE_OVERLOADING
MessageGetFirstPartyMethodInfo ,
#endif
messageGetFirstParty ,
#if ENABLE_OVERLOADING
MessageGetFlagsMethodInfo ,
#endif
messageGetFlags ,
#if ENABLE_OVERLOADING
MessageGetHttpVersionMethodInfo ,
#endif
messageGetHttpVersion ,
#if ENABLE_OVERLOADING
MessageGetHttpsStatusMethodInfo ,
#endif
messageGetHttpsStatus ,
#if ENABLE_OVERLOADING
MessageGetPriorityMethodInfo ,
#endif
messageGetPriority ,
#if ENABLE_OVERLOADING
MessageGetSoupRequestMethodInfo ,
#endif
messageGetSoupRequest ,
#if ENABLE_OVERLOADING
MessageGetUriMethodInfo ,
#endif
messageGetUri ,
#if ENABLE_OVERLOADING
MessageGotBodyMethodInfo ,
#endif
messageGotBody ,
#if ENABLE_OVERLOADING
MessageGotChunkMethodInfo ,
#endif
messageGotChunk ,
#if ENABLE_OVERLOADING
MessageGotHeadersMethodInfo ,
#endif
messageGotHeaders ,
#if ENABLE_OVERLOADING
MessageGotInformationalMethodInfo ,
#endif
messageGotInformational ,
#if ENABLE_OVERLOADING
MessageIsKeepaliveMethodInfo ,
#endif
messageIsKeepalive ,
messageNew ,
messageNewFromUri ,
#if ENABLE_OVERLOADING
MessageRestartedMethodInfo ,
#endif
messageRestarted ,
#if ENABLE_OVERLOADING
MessageSetChunkAllocatorMethodInfo ,
#endif
messageSetChunkAllocator ,
#if ENABLE_OVERLOADING
MessageSetFirstPartyMethodInfo ,
#endif
messageSetFirstParty ,
#if ENABLE_OVERLOADING
MessageSetFlagsMethodInfo ,
#endif
messageSetFlags ,
#if ENABLE_OVERLOADING
MessageSetHttpVersionMethodInfo ,
#endif
messageSetHttpVersion ,
#if ENABLE_OVERLOADING
MessageSetPriorityMethodInfo ,
#endif
messageSetPriority ,
#if ENABLE_OVERLOADING
MessageSetRedirectMethodInfo ,
#endif
messageSetRedirect ,
#if ENABLE_OVERLOADING
MessageSetRequestMethodInfo ,
#endif
messageSetRequest ,
#if ENABLE_OVERLOADING
MessageSetResponseMethodInfo ,
#endif
messageSetResponse ,
#if ENABLE_OVERLOADING
MessageSetStatusMethodInfo ,
#endif
messageSetStatus ,
#if ENABLE_OVERLOADING
MessageSetStatusFullMethodInfo ,
#endif
messageSetStatusFull ,
#if ENABLE_OVERLOADING
MessageSetUriMethodInfo ,
#endif
messageSetUri ,
#if ENABLE_OVERLOADING
MessageStartingMethodInfo ,
#endif
messageStarting ,
#if ENABLE_OVERLOADING
MessageWroteBodyMethodInfo ,
#endif
messageWroteBody ,
#if ENABLE_OVERLOADING
MessageWroteBodyDataMethodInfo ,
#endif
messageWroteBodyData ,
#if ENABLE_OVERLOADING
MessageWroteChunkMethodInfo ,
#endif
messageWroteChunk ,
#if ENABLE_OVERLOADING
MessageWroteHeadersMethodInfo ,
#endif
messageWroteHeaders ,
#if ENABLE_OVERLOADING
MessageWroteInformationalMethodInfo ,
#endif
messageWroteInformational ,
#if ENABLE_OVERLOADING
MessageFirstPartyPropertyInfo ,
#endif
constructMessageFirstParty ,
getMessageFirstParty ,
#if ENABLE_OVERLOADING
messageFirstParty ,
#endif
setMessageFirstParty ,
#if ENABLE_OVERLOADING
MessageFlagsPropertyInfo ,
#endif
constructMessageFlags ,
getMessageFlags ,
#if ENABLE_OVERLOADING
messageFlags ,
#endif
setMessageFlags ,
#if ENABLE_OVERLOADING
MessageHttpVersionPropertyInfo ,
#endif
constructMessageHttpVersion ,
getMessageHttpVersion ,
#if ENABLE_OVERLOADING
messageHttpVersion ,
#endif
setMessageHttpVersion ,
#if ENABLE_OVERLOADING
MessageMethodPropertyInfo ,
#endif
clearMessageMethod ,
constructMessageMethod ,
getMessageMethod ,
#if ENABLE_OVERLOADING
messageMethod ,
#endif
setMessageMethod ,
#if ENABLE_OVERLOADING
MessagePriorityPropertyInfo ,
#endif
constructMessagePriority ,
getMessagePriority ,
#if ENABLE_OVERLOADING
messagePriority ,
#endif
setMessagePriority ,
#if ENABLE_OVERLOADING
MessageReasonPhrasePropertyInfo ,
#endif
clearMessageReasonPhrase ,
constructMessageReasonPhrase ,
getMessageReasonPhrase ,
#if ENABLE_OVERLOADING
messageReasonPhrase ,
#endif
setMessageReasonPhrase ,
#if ENABLE_OVERLOADING
MessageRequestBodyPropertyInfo ,
#endif
getMessageRequestBody ,
#if ENABLE_OVERLOADING
messageRequestBody ,
#endif
#if ENABLE_OVERLOADING
MessageRequestBodyDataPropertyInfo ,
#endif
getMessageRequestBodyData ,
#if ENABLE_OVERLOADING
messageRequestBodyData ,
#endif
#if ENABLE_OVERLOADING
MessageRequestHeadersPropertyInfo ,
#endif
getMessageRequestHeaders ,
#if ENABLE_OVERLOADING
messageRequestHeaders ,
#endif
#if ENABLE_OVERLOADING
MessageResponseBodyPropertyInfo ,
#endif
getMessageResponseBody ,
#if ENABLE_OVERLOADING
messageResponseBody ,
#endif
#if ENABLE_OVERLOADING
MessageResponseBodyDataPropertyInfo ,
#endif
getMessageResponseBodyData ,
#if ENABLE_OVERLOADING
messageResponseBodyData ,
#endif
#if ENABLE_OVERLOADING
MessageResponseHeadersPropertyInfo ,
#endif
getMessageResponseHeaders ,
#if ENABLE_OVERLOADING
messageResponseHeaders ,
#endif
#if ENABLE_OVERLOADING
MessageServerSidePropertyInfo ,
#endif
constructMessageServerSide ,
getMessageServerSide ,
#if ENABLE_OVERLOADING
messageServerSide ,
#endif
#if ENABLE_OVERLOADING
MessageStatusCodePropertyInfo ,
#endif
constructMessageStatusCode ,
getMessageStatusCode ,
#if ENABLE_OVERLOADING
messageStatusCode ,
#endif
setMessageStatusCode ,
#if ENABLE_OVERLOADING
MessageTlsCertificatePropertyInfo ,
#endif
clearMessageTlsCertificate ,
constructMessageTlsCertificate ,
getMessageTlsCertificate ,
#if ENABLE_OVERLOADING
messageTlsCertificate ,
#endif
setMessageTlsCertificate ,
#if ENABLE_OVERLOADING
MessageTlsErrorsPropertyInfo ,
#endif
constructMessageTlsErrors ,
getMessageTlsErrors ,
#if ENABLE_OVERLOADING
messageTlsErrors ,
#endif
setMessageTlsErrors ,
#if ENABLE_OVERLOADING
MessageUriPropertyInfo ,
#endif
constructMessageUri ,
getMessageUri ,
#if ENABLE_OVERLOADING
messageUri ,
#endif
setMessageUri ,
C_MessageContentSniffedCallback ,
MessageContentSniffedCallback ,
#if ENABLE_OVERLOADING
MessageContentSniffedSignalInfo ,
#endif
afterMessageContentSniffed ,
genClosure_MessageContentSniffed ,
mk_MessageContentSniffedCallback ,
noMessageContentSniffedCallback ,
onMessageContentSniffed ,
wrap_MessageContentSniffedCallback ,
C_MessageFinishedCallback ,
MessageFinishedCallback ,
#if ENABLE_OVERLOADING
MessageFinishedSignalInfo ,
#endif
afterMessageFinished ,
genClosure_MessageFinished ,
mk_MessageFinishedCallback ,
noMessageFinishedCallback ,
onMessageFinished ,
wrap_MessageFinishedCallback ,
C_MessageGotBodyCallback ,
MessageGotBodyCallback ,
#if ENABLE_OVERLOADING
MessageGotBodySignalInfo ,
#endif
afterMessageGotBody ,
genClosure_MessageGotBody ,
mk_MessageGotBodyCallback ,
noMessageGotBodyCallback ,
onMessageGotBody ,
wrap_MessageGotBodyCallback ,
C_MessageGotChunkCallback ,
MessageGotChunkCallback ,
#if ENABLE_OVERLOADING
MessageGotChunkSignalInfo ,
#endif
afterMessageGotChunk ,
genClosure_MessageGotChunk ,
mk_MessageGotChunkCallback ,
noMessageGotChunkCallback ,
onMessageGotChunk ,
wrap_MessageGotChunkCallback ,
C_MessageGotHeadersCallback ,
MessageGotHeadersCallback ,
#if ENABLE_OVERLOADING
MessageGotHeadersSignalInfo ,
#endif
afterMessageGotHeaders ,
genClosure_MessageGotHeaders ,
mk_MessageGotHeadersCallback ,
noMessageGotHeadersCallback ,
onMessageGotHeaders ,
wrap_MessageGotHeadersCallback ,
C_MessageGotInformationalCallback ,
MessageGotInformationalCallback ,
#if ENABLE_OVERLOADING
MessageGotInformationalSignalInfo ,
#endif
afterMessageGotInformational ,
genClosure_MessageGotInformational ,
mk_MessageGotInformationalCallback ,
noMessageGotInformationalCallback ,
onMessageGotInformational ,
wrap_MessageGotInformationalCallback ,
C_MessageNetworkEventCallback ,
MessageNetworkEventCallback ,
#if ENABLE_OVERLOADING
MessageNetworkEventSignalInfo ,
#endif
afterMessageNetworkEvent ,
genClosure_MessageNetworkEvent ,
mk_MessageNetworkEventCallback ,
noMessageNetworkEventCallback ,
onMessageNetworkEvent ,
wrap_MessageNetworkEventCallback ,
C_MessageRestartedCallback ,
MessageRestartedCallback ,
#if ENABLE_OVERLOADING
MessageRestartedSignalInfo ,
#endif
afterMessageRestarted ,
genClosure_MessageRestarted ,
mk_MessageRestartedCallback ,
noMessageRestartedCallback ,
onMessageRestarted ,
wrap_MessageRestartedCallback ,
C_MessageStartingCallback ,
MessageStartingCallback ,
#if ENABLE_OVERLOADING
MessageStartingSignalInfo ,
#endif
afterMessageStarting ,
genClosure_MessageStarting ,
mk_MessageStartingCallback ,
noMessageStartingCallback ,
onMessageStarting ,
wrap_MessageStartingCallback ,
C_MessageWroteBodyCallback ,
MessageWroteBodyCallback ,
#if ENABLE_OVERLOADING
MessageWroteBodySignalInfo ,
#endif
afterMessageWroteBody ,
genClosure_MessageWroteBody ,
mk_MessageWroteBodyCallback ,
noMessageWroteBodyCallback ,
onMessageWroteBody ,
wrap_MessageWroteBodyCallback ,
C_MessageWroteBodyDataCallback ,
MessageWroteBodyDataCallback ,
#if ENABLE_OVERLOADING
MessageWroteBodyDataSignalInfo ,
#endif
afterMessageWroteBodyData ,
genClosure_MessageWroteBodyData ,
mk_MessageWroteBodyDataCallback ,
noMessageWroteBodyDataCallback ,
onMessageWroteBodyData ,
wrap_MessageWroteBodyDataCallback ,
C_MessageWroteChunkCallback ,
MessageWroteChunkCallback ,
#if ENABLE_OVERLOADING
MessageWroteChunkSignalInfo ,
#endif
afterMessageWroteChunk ,
genClosure_MessageWroteChunk ,
mk_MessageWroteChunkCallback ,
noMessageWroteChunkCallback ,
onMessageWroteChunk ,
wrap_MessageWroteChunkCallback ,
C_MessageWroteHeadersCallback ,
MessageWroteHeadersCallback ,
#if ENABLE_OVERLOADING
MessageWroteHeadersSignalInfo ,
#endif
afterMessageWroteHeaders ,
genClosure_MessageWroteHeaders ,
mk_MessageWroteHeadersCallback ,
noMessageWroteHeadersCallback ,
onMessageWroteHeaders ,
wrap_MessageWroteHeadersCallback ,
C_MessageWroteInformationalCallback ,
MessageWroteInformationalCallback ,
#if ENABLE_OVERLOADING
MessageWroteInformationalSignalInfo ,
#endif
afterMessageWroteInformational ,
genClosure_MessageWroteInformational ,
mk_MessageWroteInformationalCallback ,
noMessageWroteInformationalCallback ,
onMessageWroteInformational ,
wrap_MessageWroteInformationalCallback ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.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.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.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Enums as Gio.Enums
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Objects.IOStream as Gio.IOStream
import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import qualified GI.Soup.Callbacks as Soup.Callbacks
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Flags as Soup.Flags
import {-# SOURCE #-} qualified GI.Soup.Objects.Address as Soup.Address
import {-# SOURCE #-} qualified GI.Soup.Objects.Request as Soup.Request
import {-# SOURCE #-} qualified GI.Soup.Structs.Buffer as Soup.Buffer
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageBody as Soup.MessageBody
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders
import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI
newtype Message = Message (ManagedPtr Message)
foreign import ccall "soup_message_get_type"
c_soup_message_get_type :: IO GType
instance GObject Message where
gobjectType = c_soup_message_get_type
class (GObject o, O.IsDescendantOf Message o) => IsMessage o
instance (GObject o, O.IsDescendantOf Message o) => IsMessage o
instance O.HasParentTypes Message
type instance O.ParentTypes Message = '[GObject.Object.Object]
toMessage :: (MonadIO m, IsMessage o) => o -> m Message
toMessage = liftIO . unsafeCastTo Message
noMessage :: Maybe Message
noMessage = Nothing
#if ENABLE_OVERLOADING
type family ResolveMessageMethod (t :: Symbol) (o :: *) :: * where
ResolveMessageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveMessageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveMessageMethod "contentSniffed" o = MessageContentSniffedMethodInfo
ResolveMessageMethod "disableFeature" o = MessageDisableFeatureMethodInfo
ResolveMessageMethod "finished" o = MessageFinishedMethodInfo
ResolveMessageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveMessageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveMessageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveMessageMethod "gotBody" o = MessageGotBodyMethodInfo
ResolveMessageMethod "gotChunk" o = MessageGotChunkMethodInfo
ResolveMessageMethod "gotHeaders" o = MessageGotHeadersMethodInfo
ResolveMessageMethod "gotInformational" o = MessageGotInformationalMethodInfo
ResolveMessageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveMessageMethod "isKeepalive" o = MessageIsKeepaliveMethodInfo
ResolveMessageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveMessageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveMessageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveMessageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveMessageMethod "restarted" o = MessageRestartedMethodInfo
ResolveMessageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveMessageMethod "starting" o = MessageStartingMethodInfo
ResolveMessageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveMessageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveMessageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveMessageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveMessageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveMessageMethod "wroteBody" o = MessageWroteBodyMethodInfo
ResolveMessageMethod "wroteBodyData" o = MessageWroteBodyDataMethodInfo
ResolveMessageMethod "wroteChunk" o = MessageWroteChunkMethodInfo
ResolveMessageMethod "wroteHeaders" o = MessageWroteHeadersMethodInfo
ResolveMessageMethod "wroteInformational" o = MessageWroteInformationalMethodInfo
ResolveMessageMethod "getAddress" o = MessageGetAddressMethodInfo
ResolveMessageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveMessageMethod "getFirstParty" o = MessageGetFirstPartyMethodInfo
ResolveMessageMethod "getFlags" o = MessageGetFlagsMethodInfo
ResolveMessageMethod "getHttpVersion" o = MessageGetHttpVersionMethodInfo
ResolveMessageMethod "getHttpsStatus" o = MessageGetHttpsStatusMethodInfo
ResolveMessageMethod "getPriority" o = MessageGetPriorityMethodInfo
ResolveMessageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveMessageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveMessageMethod "getSoupRequest" o = MessageGetSoupRequestMethodInfo
ResolveMessageMethod "getUri" o = MessageGetUriMethodInfo
ResolveMessageMethod "setChunkAllocator" o = MessageSetChunkAllocatorMethodInfo
ResolveMessageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveMessageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveMessageMethod "setFirstParty" o = MessageSetFirstPartyMethodInfo
ResolveMessageMethod "setFlags" o = MessageSetFlagsMethodInfo
ResolveMessageMethod "setHttpVersion" o = MessageSetHttpVersionMethodInfo
ResolveMessageMethod "setPriority" o = MessageSetPriorityMethodInfo
ResolveMessageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveMessageMethod "setRedirect" o = MessageSetRedirectMethodInfo
ResolveMessageMethod "setRequest" o = MessageSetRequestMethodInfo
ResolveMessageMethod "setResponse" o = MessageSetResponseMethodInfo
ResolveMessageMethod "setStatus" o = MessageSetStatusMethodInfo
ResolveMessageMethod "setStatusFull" o = MessageSetStatusFullMethodInfo
ResolveMessageMethod "setUri" o = MessageSetUriMethodInfo
ResolveMessageMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMessageMethod t Message, O.MethodInfo info Message p) => OL.IsLabel t (Message -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
type MessageContentSniffedCallback =
T.Text
-> Map.Map T.Text T.Text
-> IO ()
noMessageContentSniffedCallback :: Maybe MessageContentSniffedCallback
noMessageContentSniffedCallback = Nothing
type C_MessageContentSniffedCallback =
Ptr () ->
CString ->
Ptr (GHashTable CString CString) ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageContentSniffedCallback :: C_MessageContentSniffedCallback -> IO (FunPtr C_MessageContentSniffedCallback)
genClosure_MessageContentSniffed :: MonadIO m => MessageContentSniffedCallback -> m (GClosure C_MessageContentSniffedCallback)
genClosure_MessageContentSniffed cb = liftIO $ do
let cb' = wrap_MessageContentSniffedCallback cb
mk_MessageContentSniffedCallback cb' >>= B.GClosure.newGClosure
wrap_MessageContentSniffedCallback ::
MessageContentSniffedCallback ->
C_MessageContentSniffedCallback
wrap_MessageContentSniffedCallback _cb _ type_ params _ = do
type_' <- cstringToText type_
params' <- unpackGHashTable params
let params'' = mapFirst cstringUnpackPtr params'
params''' <- mapFirstA cstringToText params''
let params'''' = mapSecond cstringUnpackPtr params'''
params''''' <- mapSecondA cstringToText params''''
let params'''''' = Map.fromList params'''''
_cb type_' params''''''
onMessageContentSniffed :: (IsMessage a, MonadIO m) => a -> MessageContentSniffedCallback -> m SignalHandlerId
onMessageContentSniffed obj cb = liftIO $ do
let cb' = wrap_MessageContentSniffedCallback cb
cb'' <- mk_MessageContentSniffedCallback cb'
connectSignalFunPtr obj "content-sniffed" cb'' SignalConnectBefore
afterMessageContentSniffed :: (IsMessage a, MonadIO m) => a -> MessageContentSniffedCallback -> m SignalHandlerId
afterMessageContentSniffed obj cb = liftIO $ do
let cb' = wrap_MessageContentSniffedCallback cb
cb'' <- mk_MessageContentSniffedCallback cb'
connectSignalFunPtr obj "content-sniffed" cb'' SignalConnectAfter
type MessageFinishedCallback =
IO ()
noMessageFinishedCallback :: Maybe MessageFinishedCallback
noMessageFinishedCallback = Nothing
type C_MessageFinishedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageFinishedCallback :: C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)
genClosure_MessageFinished :: MonadIO m => MessageFinishedCallback -> m (GClosure C_MessageFinishedCallback)
genClosure_MessageFinished cb = liftIO $ do
let cb' = wrap_MessageFinishedCallback cb
mk_MessageFinishedCallback cb' >>= B.GClosure.newGClosure
wrap_MessageFinishedCallback ::
MessageFinishedCallback ->
C_MessageFinishedCallback
wrap_MessageFinishedCallback _cb _ _ = do
_cb
onMessageFinished :: (IsMessage a, MonadIO m) => a -> MessageFinishedCallback -> m SignalHandlerId
onMessageFinished obj cb = liftIO $ do
let cb' = wrap_MessageFinishedCallback cb
cb'' <- mk_MessageFinishedCallback cb'
connectSignalFunPtr obj "finished" cb'' SignalConnectBefore
afterMessageFinished :: (IsMessage a, MonadIO m) => a -> MessageFinishedCallback -> m SignalHandlerId
afterMessageFinished obj cb = liftIO $ do
let cb' = wrap_MessageFinishedCallback cb
cb'' <- mk_MessageFinishedCallback cb'
connectSignalFunPtr obj "finished" cb'' SignalConnectAfter
type MessageGotBodyCallback =
IO ()
noMessageGotBodyCallback :: Maybe MessageGotBodyCallback
noMessageGotBodyCallback = Nothing
type C_MessageGotBodyCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageGotBodyCallback :: C_MessageGotBodyCallback -> IO (FunPtr C_MessageGotBodyCallback)
genClosure_MessageGotBody :: MonadIO m => MessageGotBodyCallback -> m (GClosure C_MessageGotBodyCallback)
genClosure_MessageGotBody cb = liftIO $ do
let cb' = wrap_MessageGotBodyCallback cb
mk_MessageGotBodyCallback cb' >>= B.GClosure.newGClosure
wrap_MessageGotBodyCallback ::
MessageGotBodyCallback ->
C_MessageGotBodyCallback
wrap_MessageGotBodyCallback _cb _ _ = do
_cb
onMessageGotBody :: (IsMessage a, MonadIO m) => a -> MessageGotBodyCallback -> m SignalHandlerId
onMessageGotBody obj cb = liftIO $ do
let cb' = wrap_MessageGotBodyCallback cb
cb'' <- mk_MessageGotBodyCallback cb'
connectSignalFunPtr obj "got-body" cb'' SignalConnectBefore
afterMessageGotBody :: (IsMessage a, MonadIO m) => a -> MessageGotBodyCallback -> m SignalHandlerId
afterMessageGotBody obj cb = liftIO $ do
let cb' = wrap_MessageGotBodyCallback cb
cb'' <- mk_MessageGotBodyCallback cb'
connectSignalFunPtr obj "got-body" cb'' SignalConnectAfter
type MessageGotChunkCallback =
Soup.Buffer.Buffer
-> IO ()
noMessageGotChunkCallback :: Maybe MessageGotChunkCallback
noMessageGotChunkCallback = Nothing
type C_MessageGotChunkCallback =
Ptr () ->
Ptr Soup.Buffer.Buffer ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageGotChunkCallback :: C_MessageGotChunkCallback -> IO (FunPtr C_MessageGotChunkCallback)
genClosure_MessageGotChunk :: MonadIO m => MessageGotChunkCallback -> m (GClosure C_MessageGotChunkCallback)
genClosure_MessageGotChunk cb = liftIO $ do
let cb' = wrap_MessageGotChunkCallback cb
mk_MessageGotChunkCallback cb' >>= B.GClosure.newGClosure
wrap_MessageGotChunkCallback ::
MessageGotChunkCallback ->
C_MessageGotChunkCallback
wrap_MessageGotChunkCallback _cb _ chunk _ = do
B.ManagedPtr.withTransient Soup.Buffer.Buffer chunk $ \chunk' -> do
_cb chunk'
onMessageGotChunk :: (IsMessage a, MonadIO m) => a -> MessageGotChunkCallback -> m SignalHandlerId
onMessageGotChunk obj cb = liftIO $ do
let cb' = wrap_MessageGotChunkCallback cb
cb'' <- mk_MessageGotChunkCallback cb'
connectSignalFunPtr obj "got-chunk" cb'' SignalConnectBefore
afterMessageGotChunk :: (IsMessage a, MonadIO m) => a -> MessageGotChunkCallback -> m SignalHandlerId
afterMessageGotChunk obj cb = liftIO $ do
let cb' = wrap_MessageGotChunkCallback cb
cb'' <- mk_MessageGotChunkCallback cb'
connectSignalFunPtr obj "got-chunk" cb'' SignalConnectAfter
type MessageGotHeadersCallback =
IO ()
noMessageGotHeadersCallback :: Maybe MessageGotHeadersCallback
noMessageGotHeadersCallback = Nothing
type C_MessageGotHeadersCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageGotHeadersCallback :: C_MessageGotHeadersCallback -> IO (FunPtr C_MessageGotHeadersCallback)
genClosure_MessageGotHeaders :: MonadIO m => MessageGotHeadersCallback -> m (GClosure C_MessageGotHeadersCallback)
genClosure_MessageGotHeaders cb = liftIO $ do
let cb' = wrap_MessageGotHeadersCallback cb
mk_MessageGotHeadersCallback cb' >>= B.GClosure.newGClosure
wrap_MessageGotHeadersCallback ::
MessageGotHeadersCallback ->
C_MessageGotHeadersCallback
wrap_MessageGotHeadersCallback _cb _ _ = do
_cb
onMessageGotHeaders :: (IsMessage a, MonadIO m) => a -> MessageGotHeadersCallback -> m SignalHandlerId
onMessageGotHeaders obj cb = liftIO $ do
let cb' = wrap_MessageGotHeadersCallback cb
cb'' <- mk_MessageGotHeadersCallback cb'
connectSignalFunPtr obj "got-headers" cb'' SignalConnectBefore
afterMessageGotHeaders :: (IsMessage a, MonadIO m) => a -> MessageGotHeadersCallback -> m SignalHandlerId
afterMessageGotHeaders obj cb = liftIO $ do
let cb' = wrap_MessageGotHeadersCallback cb
cb'' <- mk_MessageGotHeadersCallback cb'
connectSignalFunPtr obj "got-headers" cb'' SignalConnectAfter
type MessageGotInformationalCallback =
IO ()
noMessageGotInformationalCallback :: Maybe MessageGotInformationalCallback
noMessageGotInformationalCallback = Nothing
type C_MessageGotInformationalCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageGotInformationalCallback :: C_MessageGotInformationalCallback -> IO (FunPtr C_MessageGotInformationalCallback)
genClosure_MessageGotInformational :: MonadIO m => MessageGotInformationalCallback -> m (GClosure C_MessageGotInformationalCallback)
genClosure_MessageGotInformational cb = liftIO $ do
let cb' = wrap_MessageGotInformationalCallback cb
mk_MessageGotInformationalCallback cb' >>= B.GClosure.newGClosure
wrap_MessageGotInformationalCallback ::
MessageGotInformationalCallback ->
C_MessageGotInformationalCallback
wrap_MessageGotInformationalCallback _cb _ _ = do
_cb
onMessageGotInformational :: (IsMessage a, MonadIO m) => a -> MessageGotInformationalCallback -> m SignalHandlerId
onMessageGotInformational obj cb = liftIO $ do
let cb' = wrap_MessageGotInformationalCallback cb
cb'' <- mk_MessageGotInformationalCallback cb'
connectSignalFunPtr obj "got-informational" cb'' SignalConnectBefore
afterMessageGotInformational :: (IsMessage a, MonadIO m) => a -> MessageGotInformationalCallback -> m SignalHandlerId
afterMessageGotInformational obj cb = liftIO $ do
let cb' = wrap_MessageGotInformationalCallback cb
cb'' <- mk_MessageGotInformationalCallback cb'
connectSignalFunPtr obj "got-informational" cb'' SignalConnectAfter
type MessageNetworkEventCallback =
Gio.Enums.SocketClientEvent
-> Gio.IOStream.IOStream
-> IO ()
noMessageNetworkEventCallback :: Maybe MessageNetworkEventCallback
noMessageNetworkEventCallback = Nothing
type C_MessageNetworkEventCallback =
Ptr () ->
CUInt ->
Ptr Gio.IOStream.IOStream ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageNetworkEventCallback :: C_MessageNetworkEventCallback -> IO (FunPtr C_MessageNetworkEventCallback)
genClosure_MessageNetworkEvent :: MonadIO m => MessageNetworkEventCallback -> m (GClosure C_MessageNetworkEventCallback)
genClosure_MessageNetworkEvent cb = liftIO $ do
let cb' = wrap_MessageNetworkEventCallback cb
mk_MessageNetworkEventCallback cb' >>= B.GClosure.newGClosure
wrap_MessageNetworkEventCallback ::
MessageNetworkEventCallback ->
C_MessageNetworkEventCallback
wrap_MessageNetworkEventCallback _cb _ event connection _ = do
let event' = (toEnum . fromIntegral) event
connection' <- (newObject Gio.IOStream.IOStream) connection
_cb event' connection'
onMessageNetworkEvent :: (IsMessage a, MonadIO m) => a -> MessageNetworkEventCallback -> m SignalHandlerId
onMessageNetworkEvent obj cb = liftIO $ do
let cb' = wrap_MessageNetworkEventCallback cb
cb'' <- mk_MessageNetworkEventCallback cb'
connectSignalFunPtr obj "network-event" cb'' SignalConnectBefore
afterMessageNetworkEvent :: (IsMessage a, MonadIO m) => a -> MessageNetworkEventCallback -> m SignalHandlerId
afterMessageNetworkEvent obj cb = liftIO $ do
let cb' = wrap_MessageNetworkEventCallback cb
cb'' <- mk_MessageNetworkEventCallback cb'
connectSignalFunPtr obj "network-event" cb'' SignalConnectAfter
type MessageRestartedCallback =
IO ()
noMessageRestartedCallback :: Maybe MessageRestartedCallback
noMessageRestartedCallback = Nothing
type C_MessageRestartedCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageRestartedCallback :: C_MessageRestartedCallback -> IO (FunPtr C_MessageRestartedCallback)
genClosure_MessageRestarted :: MonadIO m => MessageRestartedCallback -> m (GClosure C_MessageRestartedCallback)
genClosure_MessageRestarted cb = liftIO $ do
let cb' = wrap_MessageRestartedCallback cb
mk_MessageRestartedCallback cb' >>= B.GClosure.newGClosure
wrap_MessageRestartedCallback ::
MessageRestartedCallback ->
C_MessageRestartedCallback
wrap_MessageRestartedCallback _cb _ _ = do
_cb
onMessageRestarted :: (IsMessage a, MonadIO m) => a -> MessageRestartedCallback -> m SignalHandlerId
onMessageRestarted obj cb = liftIO $ do
let cb' = wrap_MessageRestartedCallback cb
cb'' <- mk_MessageRestartedCallback cb'
connectSignalFunPtr obj "restarted" cb'' SignalConnectBefore
afterMessageRestarted :: (IsMessage a, MonadIO m) => a -> MessageRestartedCallback -> m SignalHandlerId
afterMessageRestarted obj cb = liftIO $ do
let cb' = wrap_MessageRestartedCallback cb
cb'' <- mk_MessageRestartedCallback cb'
connectSignalFunPtr obj "restarted" cb'' SignalConnectAfter
type MessageStartingCallback =
IO ()
noMessageStartingCallback :: Maybe MessageStartingCallback
noMessageStartingCallback = Nothing
type C_MessageStartingCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageStartingCallback :: C_MessageStartingCallback -> IO (FunPtr C_MessageStartingCallback)
genClosure_MessageStarting :: MonadIO m => MessageStartingCallback -> m (GClosure C_MessageStartingCallback)
genClosure_MessageStarting cb = liftIO $ do
let cb' = wrap_MessageStartingCallback cb
mk_MessageStartingCallback cb' >>= B.GClosure.newGClosure
wrap_MessageStartingCallback ::
MessageStartingCallback ->
C_MessageStartingCallback
wrap_MessageStartingCallback _cb _ _ = do
_cb
onMessageStarting :: (IsMessage a, MonadIO m) => a -> MessageStartingCallback -> m SignalHandlerId
onMessageStarting obj cb = liftIO $ do
let cb' = wrap_MessageStartingCallback cb
cb'' <- mk_MessageStartingCallback cb'
connectSignalFunPtr obj "starting" cb'' SignalConnectBefore
afterMessageStarting :: (IsMessage a, MonadIO m) => a -> MessageStartingCallback -> m SignalHandlerId
afterMessageStarting obj cb = liftIO $ do
let cb' = wrap_MessageStartingCallback cb
cb'' <- mk_MessageStartingCallback cb'
connectSignalFunPtr obj "starting" cb'' SignalConnectAfter
type MessageWroteBodyCallback =
IO ()
noMessageWroteBodyCallback :: Maybe MessageWroteBodyCallback
noMessageWroteBodyCallback = Nothing
type C_MessageWroteBodyCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageWroteBodyCallback :: C_MessageWroteBodyCallback -> IO (FunPtr C_MessageWroteBodyCallback)
genClosure_MessageWroteBody :: MonadIO m => MessageWroteBodyCallback -> m (GClosure C_MessageWroteBodyCallback)
genClosure_MessageWroteBody cb = liftIO $ do
let cb' = wrap_MessageWroteBodyCallback cb
mk_MessageWroteBodyCallback cb' >>= B.GClosure.newGClosure
wrap_MessageWroteBodyCallback ::
MessageWroteBodyCallback ->
C_MessageWroteBodyCallback
wrap_MessageWroteBodyCallback _cb _ _ = do
_cb
onMessageWroteBody :: (IsMessage a, MonadIO m) => a -> MessageWroteBodyCallback -> m SignalHandlerId
onMessageWroteBody obj cb = liftIO $ do
let cb' = wrap_MessageWroteBodyCallback cb
cb'' <- mk_MessageWroteBodyCallback cb'
connectSignalFunPtr obj "wrote-body" cb'' SignalConnectBefore
afterMessageWroteBody :: (IsMessage a, MonadIO m) => a -> MessageWroteBodyCallback -> m SignalHandlerId
afterMessageWroteBody obj cb = liftIO $ do
let cb' = wrap_MessageWroteBodyCallback cb
cb'' <- mk_MessageWroteBodyCallback cb'
connectSignalFunPtr obj "wrote-body" cb'' SignalConnectAfter
type MessageWroteBodyDataCallback =
Soup.Buffer.Buffer
-> IO ()
noMessageWroteBodyDataCallback :: Maybe MessageWroteBodyDataCallback
noMessageWroteBodyDataCallback = Nothing
type C_MessageWroteBodyDataCallback =
Ptr () ->
Ptr Soup.Buffer.Buffer ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageWroteBodyDataCallback :: C_MessageWroteBodyDataCallback -> IO (FunPtr C_MessageWroteBodyDataCallback)
genClosure_MessageWroteBodyData :: MonadIO m => MessageWroteBodyDataCallback -> m (GClosure C_MessageWroteBodyDataCallback)
genClosure_MessageWroteBodyData cb = liftIO $ do
let cb' = wrap_MessageWroteBodyDataCallback cb
mk_MessageWroteBodyDataCallback cb' >>= B.GClosure.newGClosure
wrap_MessageWroteBodyDataCallback ::
MessageWroteBodyDataCallback ->
C_MessageWroteBodyDataCallback
wrap_MessageWroteBodyDataCallback _cb _ chunk _ = do
B.ManagedPtr.withTransient Soup.Buffer.Buffer chunk $ \chunk' -> do
_cb chunk'
onMessageWroteBodyData :: (IsMessage a, MonadIO m) => a -> MessageWroteBodyDataCallback -> m SignalHandlerId
onMessageWroteBodyData obj cb = liftIO $ do
let cb' = wrap_MessageWroteBodyDataCallback cb
cb'' <- mk_MessageWroteBodyDataCallback cb'
connectSignalFunPtr obj "wrote-body-data" cb'' SignalConnectBefore
afterMessageWroteBodyData :: (IsMessage a, MonadIO m) => a -> MessageWroteBodyDataCallback -> m SignalHandlerId
afterMessageWroteBodyData obj cb = liftIO $ do
let cb' = wrap_MessageWroteBodyDataCallback cb
cb'' <- mk_MessageWroteBodyDataCallback cb'
connectSignalFunPtr obj "wrote-body-data" cb'' SignalConnectAfter
type MessageWroteChunkCallback =
IO ()
noMessageWroteChunkCallback :: Maybe MessageWroteChunkCallback
noMessageWroteChunkCallback = Nothing
type C_MessageWroteChunkCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageWroteChunkCallback :: C_MessageWroteChunkCallback -> IO (FunPtr C_MessageWroteChunkCallback)
genClosure_MessageWroteChunk :: MonadIO m => MessageWroteChunkCallback -> m (GClosure C_MessageWroteChunkCallback)
genClosure_MessageWroteChunk cb = liftIO $ do
let cb' = wrap_MessageWroteChunkCallback cb
mk_MessageWroteChunkCallback cb' >>= B.GClosure.newGClosure
wrap_MessageWroteChunkCallback ::
MessageWroteChunkCallback ->
C_MessageWroteChunkCallback
wrap_MessageWroteChunkCallback _cb _ _ = do
_cb
onMessageWroteChunk :: (IsMessage a, MonadIO m) => a -> MessageWroteChunkCallback -> m SignalHandlerId
onMessageWroteChunk obj cb = liftIO $ do
let cb' = wrap_MessageWroteChunkCallback cb
cb'' <- mk_MessageWroteChunkCallback cb'
connectSignalFunPtr obj "wrote-chunk" cb'' SignalConnectBefore
afterMessageWroteChunk :: (IsMessage a, MonadIO m) => a -> MessageWroteChunkCallback -> m SignalHandlerId
afterMessageWroteChunk obj cb = liftIO $ do
let cb' = wrap_MessageWroteChunkCallback cb
cb'' <- mk_MessageWroteChunkCallback cb'
connectSignalFunPtr obj "wrote-chunk" cb'' SignalConnectAfter
type MessageWroteHeadersCallback =
IO ()
noMessageWroteHeadersCallback :: Maybe MessageWroteHeadersCallback
noMessageWroteHeadersCallback = Nothing
type C_MessageWroteHeadersCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageWroteHeadersCallback :: C_MessageWroteHeadersCallback -> IO (FunPtr C_MessageWroteHeadersCallback)
genClosure_MessageWroteHeaders :: MonadIO m => MessageWroteHeadersCallback -> m (GClosure C_MessageWroteHeadersCallback)
genClosure_MessageWroteHeaders cb = liftIO $ do
let cb' = wrap_MessageWroteHeadersCallback cb
mk_MessageWroteHeadersCallback cb' >>= B.GClosure.newGClosure
wrap_MessageWroteHeadersCallback ::
MessageWroteHeadersCallback ->
C_MessageWroteHeadersCallback
wrap_MessageWroteHeadersCallback _cb _ _ = do
_cb
onMessageWroteHeaders :: (IsMessage a, MonadIO m) => a -> MessageWroteHeadersCallback -> m SignalHandlerId
onMessageWroteHeaders obj cb = liftIO $ do
let cb' = wrap_MessageWroteHeadersCallback cb
cb'' <- mk_MessageWroteHeadersCallback cb'
connectSignalFunPtr obj "wrote-headers" cb'' SignalConnectBefore
afterMessageWroteHeaders :: (IsMessage a, MonadIO m) => a -> MessageWroteHeadersCallback -> m SignalHandlerId
afterMessageWroteHeaders obj cb = liftIO $ do
let cb' = wrap_MessageWroteHeadersCallback cb
cb'' <- mk_MessageWroteHeadersCallback cb'
connectSignalFunPtr obj "wrote-headers" cb'' SignalConnectAfter
type MessageWroteInformationalCallback =
IO ()
noMessageWroteInformationalCallback :: Maybe MessageWroteInformationalCallback
noMessageWroteInformationalCallback = Nothing
type C_MessageWroteInformationalCallback =
Ptr () ->
Ptr () ->
IO ()
foreign import ccall "wrapper"
mk_MessageWroteInformationalCallback :: C_MessageWroteInformationalCallback -> IO (FunPtr C_MessageWroteInformationalCallback)
genClosure_MessageWroteInformational :: MonadIO m => MessageWroteInformationalCallback -> m (GClosure C_MessageWroteInformationalCallback)
genClosure_MessageWroteInformational cb = liftIO $ do
let cb' = wrap_MessageWroteInformationalCallback cb
mk_MessageWroteInformationalCallback cb' >>= B.GClosure.newGClosure
wrap_MessageWroteInformationalCallback ::
MessageWroteInformationalCallback ->
C_MessageWroteInformationalCallback
wrap_MessageWroteInformationalCallback _cb _ _ = do
_cb
onMessageWroteInformational :: (IsMessage a, MonadIO m) => a -> MessageWroteInformationalCallback -> m SignalHandlerId
onMessageWroteInformational obj cb = liftIO $ do
let cb' = wrap_MessageWroteInformationalCallback cb
cb'' <- mk_MessageWroteInformationalCallback cb'
connectSignalFunPtr obj "wrote-informational" cb'' SignalConnectBefore
afterMessageWroteInformational :: (IsMessage a, MonadIO m) => a -> MessageWroteInformationalCallback -> m SignalHandlerId
afterMessageWroteInformational obj cb = liftIO $ do
let cb' = wrap_MessageWroteInformationalCallback cb
cb'' <- mk_MessageWroteInformationalCallback cb'
connectSignalFunPtr obj "wrote-informational" cb'' SignalConnectAfter
getMessageFirstParty :: (MonadIO m, IsMessage o) => o -> m Soup.URI.URI
getMessageFirstParty obj = liftIO $ checkUnexpectedNothing "getMessageFirstParty" $ B.Properties.getObjectPropertyBoxed obj "first-party" Soup.URI.URI
setMessageFirstParty :: (MonadIO m, IsMessage o) => o -> Soup.URI.URI -> m ()
setMessageFirstParty obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "first-party" (Just val)
constructMessageFirstParty :: (IsMessage o) => Soup.URI.URI -> IO (GValueConstruct o)
constructMessageFirstParty val = B.Properties.constructObjectPropertyBoxed "first-party" (Just val)
#if ENABLE_OVERLOADING
data MessageFirstPartyPropertyInfo
instance AttrInfo MessageFirstPartyPropertyInfo where
type AttrAllowedOps MessageFirstPartyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint MessageFirstPartyPropertyInfo = (~) Soup.URI.URI
type AttrBaseTypeConstraint MessageFirstPartyPropertyInfo = IsMessage
type AttrGetType MessageFirstPartyPropertyInfo = Soup.URI.URI
type AttrLabel MessageFirstPartyPropertyInfo = "first-party"
type AttrOrigin MessageFirstPartyPropertyInfo = Message
attrGet _ = getMessageFirstParty
attrSet _ = setMessageFirstParty
attrConstruct _ = constructMessageFirstParty
attrClear _ = undefined
#endif
getMessageFlags :: (MonadIO m, IsMessage o) => o -> m [Soup.Flags.MessageFlags]
getMessageFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "flags"
setMessageFlags :: (MonadIO m, IsMessage o) => o -> [Soup.Flags.MessageFlags] -> m ()
setMessageFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "flags" val
constructMessageFlags :: (IsMessage o) => [Soup.Flags.MessageFlags] -> IO (GValueConstruct o)
constructMessageFlags val = B.Properties.constructObjectPropertyFlags "flags" val
#if ENABLE_OVERLOADING
data MessageFlagsPropertyInfo
instance AttrInfo MessageFlagsPropertyInfo where
type AttrAllowedOps MessageFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint MessageFlagsPropertyInfo = (~) [Soup.Flags.MessageFlags]
type AttrBaseTypeConstraint MessageFlagsPropertyInfo = IsMessage
type AttrGetType MessageFlagsPropertyInfo = [Soup.Flags.MessageFlags]
type AttrLabel MessageFlagsPropertyInfo = "flags"
type AttrOrigin MessageFlagsPropertyInfo = Message
attrGet _ = getMessageFlags
attrSet _ = setMessageFlags
attrConstruct _ = constructMessageFlags
attrClear _ = undefined
#endif
getMessageHttpVersion :: (MonadIO m, IsMessage o) => o -> m Soup.Enums.HTTPVersion
getMessageHttpVersion obj = liftIO $ B.Properties.getObjectPropertyEnum obj "http-version"
setMessageHttpVersion :: (MonadIO m, IsMessage o) => o -> Soup.Enums.HTTPVersion -> m ()
setMessageHttpVersion obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "http-version" val
constructMessageHttpVersion :: (IsMessage o) => Soup.Enums.HTTPVersion -> IO (GValueConstruct o)
constructMessageHttpVersion val = B.Properties.constructObjectPropertyEnum "http-version" val
#if ENABLE_OVERLOADING
data MessageHttpVersionPropertyInfo
instance AttrInfo MessageHttpVersionPropertyInfo where
type AttrAllowedOps MessageHttpVersionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint MessageHttpVersionPropertyInfo = (~) Soup.Enums.HTTPVersion
type AttrBaseTypeConstraint MessageHttpVersionPropertyInfo = IsMessage
type AttrGetType MessageHttpVersionPropertyInfo = Soup.Enums.HTTPVersion
type AttrLabel MessageHttpVersionPropertyInfo = "http-version"
type AttrOrigin MessageHttpVersionPropertyInfo = Message
attrGet _ = getMessageHttpVersion
attrSet _ = setMessageHttpVersion
attrConstruct _ = constructMessageHttpVersion
attrClear _ = undefined
#endif
getMessageMethod :: (MonadIO m, IsMessage o) => o -> m (Maybe T.Text)
getMessageMethod obj = liftIO $ B.Properties.getObjectPropertyString obj "method"
setMessageMethod :: (MonadIO m, IsMessage o) => o -> T.Text -> m ()
setMessageMethod obj val = liftIO $ B.Properties.setObjectPropertyString obj "method" (Just val)
constructMessageMethod :: (IsMessage o) => T.Text -> IO (GValueConstruct o)
constructMessageMethod val = B.Properties.constructObjectPropertyString "method" (Just val)
clearMessageMethod :: (MonadIO m, IsMessage o) => o -> m ()
clearMessageMethod obj = liftIO $ B.Properties.setObjectPropertyString obj "method" (Nothing :: Maybe T.Text)
#if ENABLE_OVERLOADING
data MessageMethodPropertyInfo
instance AttrInfo MessageMethodPropertyInfo where
type AttrAllowedOps MessageMethodPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageMethodPropertyInfo = (~) T.Text
type AttrBaseTypeConstraint MessageMethodPropertyInfo = IsMessage
type AttrGetType MessageMethodPropertyInfo = (Maybe T.Text)
type AttrLabel MessageMethodPropertyInfo = "method"
type AttrOrigin MessageMethodPropertyInfo = Message
attrGet _ = getMessageMethod
attrSet _ = setMessageMethod
attrConstruct _ = constructMessageMethod
attrClear _ = clearMessageMethod
#endif
getMessagePriority :: (MonadIO m, IsMessage o) => o -> m Soup.Enums.MessagePriority
getMessagePriority obj = liftIO $ B.Properties.getObjectPropertyEnum obj "priority"
setMessagePriority :: (MonadIO m, IsMessage o) => o -> Soup.Enums.MessagePriority -> m ()
setMessagePriority obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "priority" val
constructMessagePriority :: (IsMessage o) => Soup.Enums.MessagePriority -> IO (GValueConstruct o)
constructMessagePriority val = B.Properties.constructObjectPropertyEnum "priority" val
#if ENABLE_OVERLOADING
data MessagePriorityPropertyInfo
instance AttrInfo MessagePriorityPropertyInfo where
type AttrAllowedOps MessagePriorityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint MessagePriorityPropertyInfo = (~) Soup.Enums.MessagePriority
type AttrBaseTypeConstraint MessagePriorityPropertyInfo = IsMessage
type AttrGetType MessagePriorityPropertyInfo = Soup.Enums.MessagePriority
type AttrLabel MessagePriorityPropertyInfo = "priority"
type AttrOrigin MessagePriorityPropertyInfo = Message
attrGet _ = getMessagePriority
attrSet _ = setMessagePriority
attrConstruct _ = constructMessagePriority
attrClear _ = undefined
#endif
getMessageReasonPhrase :: (MonadIO m, IsMessage o) => o -> m (Maybe T.Text)
getMessageReasonPhrase obj = liftIO $ B.Properties.getObjectPropertyString obj "reason-phrase"
setMessageReasonPhrase :: (MonadIO m, IsMessage o) => o -> T.Text -> m ()
setMessageReasonPhrase obj val = liftIO $ B.Properties.setObjectPropertyString obj "reason-phrase" (Just val)
constructMessageReasonPhrase :: (IsMessage o) => T.Text -> IO (GValueConstruct o)
constructMessageReasonPhrase val = B.Properties.constructObjectPropertyString "reason-phrase" (Just val)
clearMessageReasonPhrase :: (MonadIO m, IsMessage o) => o -> m ()
clearMessageReasonPhrase obj = liftIO $ B.Properties.setObjectPropertyString obj "reason-phrase" (Nothing :: Maybe T.Text)
#if ENABLE_OVERLOADING
data MessageReasonPhrasePropertyInfo
instance AttrInfo MessageReasonPhrasePropertyInfo where
type AttrAllowedOps MessageReasonPhrasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageReasonPhrasePropertyInfo = (~) T.Text
type AttrBaseTypeConstraint MessageReasonPhrasePropertyInfo = IsMessage
type AttrGetType MessageReasonPhrasePropertyInfo = (Maybe T.Text)
type AttrLabel MessageReasonPhrasePropertyInfo = "reason-phrase"
type AttrOrigin MessageReasonPhrasePropertyInfo = Message
attrGet _ = getMessageReasonPhrase
attrSet _ = setMessageReasonPhrase
attrConstruct _ = constructMessageReasonPhrase
attrClear _ = clearMessageReasonPhrase
#endif
getMessageRequestBody :: (MonadIO m, IsMessage o) => o -> m (Maybe Soup.MessageBody.MessageBody)
getMessageRequestBody obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "request-body" Soup.MessageBody.MessageBody
#if ENABLE_OVERLOADING
data MessageRequestBodyPropertyInfo
instance AttrInfo MessageRequestBodyPropertyInfo where
type AttrAllowedOps MessageRequestBodyPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageRequestBodyPropertyInfo = (~) ()
type AttrBaseTypeConstraint MessageRequestBodyPropertyInfo = IsMessage
type AttrGetType MessageRequestBodyPropertyInfo = (Maybe Soup.MessageBody.MessageBody)
type AttrLabel MessageRequestBodyPropertyInfo = "request-body"
type AttrOrigin MessageRequestBodyPropertyInfo = Message
attrGet _ = getMessageRequestBody
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getMessageRequestBodyData :: (MonadIO m, IsMessage o) => o -> m (Maybe GLib.Bytes.Bytes)
getMessageRequestBodyData obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "request-body-data" GLib.Bytes.Bytes
#if ENABLE_OVERLOADING
data MessageRequestBodyDataPropertyInfo
instance AttrInfo MessageRequestBodyDataPropertyInfo where
type AttrAllowedOps MessageRequestBodyDataPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageRequestBodyDataPropertyInfo = (~) ()
type AttrBaseTypeConstraint MessageRequestBodyDataPropertyInfo = IsMessage
type AttrGetType MessageRequestBodyDataPropertyInfo = (Maybe GLib.Bytes.Bytes)
type AttrLabel MessageRequestBodyDataPropertyInfo = "request-body-data"
type AttrOrigin MessageRequestBodyDataPropertyInfo = Message
attrGet _ = getMessageRequestBodyData
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getMessageRequestHeaders :: (MonadIO m, IsMessage o) => o -> m (Maybe Soup.MessageHeaders.MessageHeaders)
getMessageRequestHeaders obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "request-headers" Soup.MessageHeaders.MessageHeaders
#if ENABLE_OVERLOADING
data MessageRequestHeadersPropertyInfo
instance AttrInfo MessageRequestHeadersPropertyInfo where
type AttrAllowedOps MessageRequestHeadersPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageRequestHeadersPropertyInfo = (~) ()
type AttrBaseTypeConstraint MessageRequestHeadersPropertyInfo = IsMessage
type AttrGetType MessageRequestHeadersPropertyInfo = (Maybe Soup.MessageHeaders.MessageHeaders)
type AttrLabel MessageRequestHeadersPropertyInfo = "request-headers"
type AttrOrigin MessageRequestHeadersPropertyInfo = Message
attrGet _ = getMessageRequestHeaders
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getMessageResponseBody :: (MonadIO m, IsMessage o) => o -> m (Maybe Soup.MessageBody.MessageBody)
getMessageResponseBody obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "response-body" Soup.MessageBody.MessageBody
#if ENABLE_OVERLOADING
data MessageResponseBodyPropertyInfo
instance AttrInfo MessageResponseBodyPropertyInfo where
type AttrAllowedOps MessageResponseBodyPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageResponseBodyPropertyInfo = (~) ()
type AttrBaseTypeConstraint MessageResponseBodyPropertyInfo = IsMessage
type AttrGetType MessageResponseBodyPropertyInfo = (Maybe Soup.MessageBody.MessageBody)
type AttrLabel MessageResponseBodyPropertyInfo = "response-body"
type AttrOrigin MessageResponseBodyPropertyInfo = Message
attrGet _ = getMessageResponseBody
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getMessageResponseBodyData :: (MonadIO m, IsMessage o) => o -> m (Maybe GLib.Bytes.Bytes)
getMessageResponseBodyData obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "response-body-data" GLib.Bytes.Bytes
#if ENABLE_OVERLOADING
data MessageResponseBodyDataPropertyInfo
instance AttrInfo MessageResponseBodyDataPropertyInfo where
type AttrAllowedOps MessageResponseBodyDataPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageResponseBodyDataPropertyInfo = (~) ()
type AttrBaseTypeConstraint MessageResponseBodyDataPropertyInfo = IsMessage
type AttrGetType MessageResponseBodyDataPropertyInfo = (Maybe GLib.Bytes.Bytes)
type AttrLabel MessageResponseBodyDataPropertyInfo = "response-body-data"
type AttrOrigin MessageResponseBodyDataPropertyInfo = Message
attrGet _ = getMessageResponseBodyData
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getMessageResponseHeaders :: (MonadIO m, IsMessage o) => o -> m (Maybe Soup.MessageHeaders.MessageHeaders)
getMessageResponseHeaders obj = liftIO $ B.Properties.getObjectPropertyBoxed obj "response-headers" Soup.MessageHeaders.MessageHeaders
#if ENABLE_OVERLOADING
data MessageResponseHeadersPropertyInfo
instance AttrInfo MessageResponseHeadersPropertyInfo where
type AttrAllowedOps MessageResponseHeadersPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageResponseHeadersPropertyInfo = (~) ()
type AttrBaseTypeConstraint MessageResponseHeadersPropertyInfo = IsMessage
type AttrGetType MessageResponseHeadersPropertyInfo = (Maybe Soup.MessageHeaders.MessageHeaders)
type AttrLabel MessageResponseHeadersPropertyInfo = "response-headers"
type AttrOrigin MessageResponseHeadersPropertyInfo = Message
attrGet _ = getMessageResponseHeaders
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
getMessageServerSide :: (MonadIO m, IsMessage o) => o -> m Bool
getMessageServerSide obj = liftIO $ B.Properties.getObjectPropertyBool obj "server-side"
constructMessageServerSide :: (IsMessage o) => Bool -> IO (GValueConstruct o)
constructMessageServerSide val = B.Properties.constructObjectPropertyBool "server-side" val
#if ENABLE_OVERLOADING
data MessageServerSidePropertyInfo
instance AttrInfo MessageServerSidePropertyInfo where
type AttrAllowedOps MessageServerSidePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint MessageServerSidePropertyInfo = (~) Bool
type AttrBaseTypeConstraint MessageServerSidePropertyInfo = IsMessage
type AttrGetType MessageServerSidePropertyInfo = Bool
type AttrLabel MessageServerSidePropertyInfo = "server-side"
type AttrOrigin MessageServerSidePropertyInfo = Message
attrGet _ = getMessageServerSide
attrSet _ = undefined
attrConstruct _ = constructMessageServerSide
attrClear _ = undefined
#endif
getMessageStatusCode :: (MonadIO m, IsMessage o) => o -> m Word32
getMessageStatusCode obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "status-code"
setMessageStatusCode :: (MonadIO m, IsMessage o) => o -> Word32 -> m ()
setMessageStatusCode obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "status-code" val
constructMessageStatusCode :: (IsMessage o) => Word32 -> IO (GValueConstruct o)
constructMessageStatusCode val = B.Properties.constructObjectPropertyUInt32 "status-code" val
#if ENABLE_OVERLOADING
data MessageStatusCodePropertyInfo
instance AttrInfo MessageStatusCodePropertyInfo where
type AttrAllowedOps MessageStatusCodePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint MessageStatusCodePropertyInfo = (~) Word32
type AttrBaseTypeConstraint MessageStatusCodePropertyInfo = IsMessage
type AttrGetType MessageStatusCodePropertyInfo = Word32
type AttrLabel MessageStatusCodePropertyInfo = "status-code"
type AttrOrigin MessageStatusCodePropertyInfo = Message
attrGet _ = getMessageStatusCode
attrSet _ = setMessageStatusCode
attrConstruct _ = constructMessageStatusCode
attrClear _ = undefined
#endif
getMessageTlsCertificate :: (MonadIO m, IsMessage o) => o -> m (Maybe Gio.TlsCertificate.TlsCertificate)
getMessageTlsCertificate obj = liftIO $ B.Properties.getObjectPropertyObject obj "tls-certificate" Gio.TlsCertificate.TlsCertificate
setMessageTlsCertificate :: (MonadIO m, IsMessage o, Gio.TlsCertificate.IsTlsCertificate a) => o -> a -> m ()
setMessageTlsCertificate obj val = liftIO $ B.Properties.setObjectPropertyObject obj "tls-certificate" (Just val)
constructMessageTlsCertificate :: (IsMessage o, Gio.TlsCertificate.IsTlsCertificate a) => a -> IO (GValueConstruct o)
constructMessageTlsCertificate val = B.Properties.constructObjectPropertyObject "tls-certificate" (Just val)
clearMessageTlsCertificate :: (MonadIO m, IsMessage o) => o -> m ()
clearMessageTlsCertificate obj = liftIO $ B.Properties.setObjectPropertyObject obj "tls-certificate" (Nothing :: Maybe Gio.TlsCertificate.TlsCertificate)
#if ENABLE_OVERLOADING
data MessageTlsCertificatePropertyInfo
instance AttrInfo MessageTlsCertificatePropertyInfo where
type AttrAllowedOps MessageTlsCertificatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MessageTlsCertificatePropertyInfo = Gio.TlsCertificate.IsTlsCertificate
type AttrBaseTypeConstraint MessageTlsCertificatePropertyInfo = IsMessage
type AttrGetType MessageTlsCertificatePropertyInfo = (Maybe Gio.TlsCertificate.TlsCertificate)
type AttrLabel MessageTlsCertificatePropertyInfo = "tls-certificate"
type AttrOrigin MessageTlsCertificatePropertyInfo = Message
attrGet _ = getMessageTlsCertificate
attrSet _ = setMessageTlsCertificate
attrConstruct _ = constructMessageTlsCertificate
attrClear _ = clearMessageTlsCertificate
#endif
getMessageTlsErrors :: (MonadIO m, IsMessage o) => o -> m [Gio.Flags.TlsCertificateFlags]
getMessageTlsErrors obj = liftIO $ B.Properties.getObjectPropertyFlags obj "tls-errors"
setMessageTlsErrors :: (MonadIO m, IsMessage o) => o -> [Gio.Flags.TlsCertificateFlags] -> m ()
setMessageTlsErrors obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "tls-errors" val
constructMessageTlsErrors :: (IsMessage o) => [Gio.Flags.TlsCertificateFlags] -> IO (GValueConstruct o)
constructMessageTlsErrors val = B.Properties.constructObjectPropertyFlags "tls-errors" val
#if ENABLE_OVERLOADING
data MessageTlsErrorsPropertyInfo
instance AttrInfo MessageTlsErrorsPropertyInfo where
type AttrAllowedOps MessageTlsErrorsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint MessageTlsErrorsPropertyInfo = (~) [Gio.Flags.TlsCertificateFlags]
type AttrBaseTypeConstraint MessageTlsErrorsPropertyInfo = IsMessage
type AttrGetType MessageTlsErrorsPropertyInfo = [Gio.Flags.TlsCertificateFlags]
type AttrLabel MessageTlsErrorsPropertyInfo = "tls-errors"
type AttrOrigin MessageTlsErrorsPropertyInfo = Message
attrGet _ = getMessageTlsErrors
attrSet _ = setMessageTlsErrors
attrConstruct _ = constructMessageTlsErrors
attrClear _ = undefined
#endif
getMessageUri :: (MonadIO m, IsMessage o) => o -> m Soup.URI.URI
getMessageUri obj = liftIO $ checkUnexpectedNothing "getMessageUri" $ B.Properties.getObjectPropertyBoxed obj "uri" Soup.URI.URI
setMessageUri :: (MonadIO m, IsMessage o) => o -> Soup.URI.URI -> m ()
setMessageUri obj val = liftIO $ B.Properties.setObjectPropertyBoxed obj "uri" (Just val)
constructMessageUri :: (IsMessage o) => Soup.URI.URI -> IO (GValueConstruct o)
constructMessageUri val = B.Properties.constructObjectPropertyBoxed "uri" (Just val)
#if ENABLE_OVERLOADING
data MessageUriPropertyInfo
instance AttrInfo MessageUriPropertyInfo where
type AttrAllowedOps MessageUriPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint MessageUriPropertyInfo = (~) Soup.URI.URI
type AttrBaseTypeConstraint MessageUriPropertyInfo = IsMessage
type AttrGetType MessageUriPropertyInfo = Soup.URI.URI
type AttrLabel MessageUriPropertyInfo = "uri"
type AttrOrigin MessageUriPropertyInfo = Message
attrGet _ = getMessageUri
attrSet _ = setMessageUri
attrConstruct _ = constructMessageUri
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList Message
type instance O.AttributeList Message = MessageAttributeList
type MessageAttributeList = ('[ '("firstParty", MessageFirstPartyPropertyInfo), '("flags", MessageFlagsPropertyInfo), '("httpVersion", MessageHttpVersionPropertyInfo), '("method", MessageMethodPropertyInfo), '("priority", MessagePriorityPropertyInfo), '("reasonPhrase", MessageReasonPhrasePropertyInfo), '("requestBody", MessageRequestBodyPropertyInfo), '("requestBodyData", MessageRequestBodyDataPropertyInfo), '("requestHeaders", MessageRequestHeadersPropertyInfo), '("responseBody", MessageResponseBodyPropertyInfo), '("responseBodyData", MessageResponseBodyDataPropertyInfo), '("responseHeaders", MessageResponseHeadersPropertyInfo), '("serverSide", MessageServerSidePropertyInfo), '("statusCode", MessageStatusCodePropertyInfo), '("tlsCertificate", MessageTlsCertificatePropertyInfo), '("tlsErrors", MessageTlsErrorsPropertyInfo), '("uri", MessageUriPropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
messageFirstParty :: AttrLabelProxy "firstParty"
messageFirstParty = AttrLabelProxy
messageFlags :: AttrLabelProxy "flags"
messageFlags = AttrLabelProxy
messageHttpVersion :: AttrLabelProxy "httpVersion"
messageHttpVersion = AttrLabelProxy
messageMethod :: AttrLabelProxy "method"
messageMethod = AttrLabelProxy
messagePriority :: AttrLabelProxy "priority"
messagePriority = AttrLabelProxy
messageReasonPhrase :: AttrLabelProxy "reasonPhrase"
messageReasonPhrase = AttrLabelProxy
messageRequestBody :: AttrLabelProxy "requestBody"
messageRequestBody = AttrLabelProxy
messageRequestBodyData :: AttrLabelProxy "requestBodyData"
messageRequestBodyData = AttrLabelProxy
messageRequestHeaders :: AttrLabelProxy "requestHeaders"
messageRequestHeaders = AttrLabelProxy
messageResponseBody :: AttrLabelProxy "responseBody"
messageResponseBody = AttrLabelProxy
messageResponseBodyData :: AttrLabelProxy "responseBodyData"
messageResponseBodyData = AttrLabelProxy
messageResponseHeaders :: AttrLabelProxy "responseHeaders"
messageResponseHeaders = AttrLabelProxy
messageServerSide :: AttrLabelProxy "serverSide"
messageServerSide = AttrLabelProxy
messageStatusCode :: AttrLabelProxy "statusCode"
messageStatusCode = AttrLabelProxy
messageTlsCertificate :: AttrLabelProxy "tlsCertificate"
messageTlsCertificate = AttrLabelProxy
messageTlsErrors :: AttrLabelProxy "tlsErrors"
messageTlsErrors = AttrLabelProxy
messageUri :: AttrLabelProxy "uri"
messageUri = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
data MessageContentSniffedSignalInfo
instance SignalInfo MessageContentSniffedSignalInfo where
type HaskellCallbackType MessageContentSniffedSignalInfo = MessageContentSniffedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageContentSniffedCallback cb
cb'' <- mk_MessageContentSniffedCallback cb'
connectSignalFunPtr obj "content-sniffed" cb'' connectMode
data MessageFinishedSignalInfo
instance SignalInfo MessageFinishedSignalInfo where
type HaskellCallbackType MessageFinishedSignalInfo = MessageFinishedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageFinishedCallback cb
cb'' <- mk_MessageFinishedCallback cb'
connectSignalFunPtr obj "finished" cb'' connectMode
data MessageGotBodySignalInfo
instance SignalInfo MessageGotBodySignalInfo where
type HaskellCallbackType MessageGotBodySignalInfo = MessageGotBodyCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageGotBodyCallback cb
cb'' <- mk_MessageGotBodyCallback cb'
connectSignalFunPtr obj "got-body" cb'' connectMode
data MessageGotChunkSignalInfo
instance SignalInfo MessageGotChunkSignalInfo where
type HaskellCallbackType MessageGotChunkSignalInfo = MessageGotChunkCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageGotChunkCallback cb
cb'' <- mk_MessageGotChunkCallback cb'
connectSignalFunPtr obj "got-chunk" cb'' connectMode
data MessageGotHeadersSignalInfo
instance SignalInfo MessageGotHeadersSignalInfo where
type HaskellCallbackType MessageGotHeadersSignalInfo = MessageGotHeadersCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageGotHeadersCallback cb
cb'' <- mk_MessageGotHeadersCallback cb'
connectSignalFunPtr obj "got-headers" cb'' connectMode
data MessageGotInformationalSignalInfo
instance SignalInfo MessageGotInformationalSignalInfo where
type HaskellCallbackType MessageGotInformationalSignalInfo = MessageGotInformationalCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageGotInformationalCallback cb
cb'' <- mk_MessageGotInformationalCallback cb'
connectSignalFunPtr obj "got-informational" cb'' connectMode
data MessageNetworkEventSignalInfo
instance SignalInfo MessageNetworkEventSignalInfo where
type HaskellCallbackType MessageNetworkEventSignalInfo = MessageNetworkEventCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageNetworkEventCallback cb
cb'' <- mk_MessageNetworkEventCallback cb'
connectSignalFunPtr obj "network-event" cb'' connectMode
data MessageRestartedSignalInfo
instance SignalInfo MessageRestartedSignalInfo where
type HaskellCallbackType MessageRestartedSignalInfo = MessageRestartedCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageRestartedCallback cb
cb'' <- mk_MessageRestartedCallback cb'
connectSignalFunPtr obj "restarted" cb'' connectMode
data MessageStartingSignalInfo
instance SignalInfo MessageStartingSignalInfo where
type HaskellCallbackType MessageStartingSignalInfo = MessageStartingCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageStartingCallback cb
cb'' <- mk_MessageStartingCallback cb'
connectSignalFunPtr obj "starting" cb'' connectMode
data MessageWroteBodySignalInfo
instance SignalInfo MessageWroteBodySignalInfo where
type HaskellCallbackType MessageWroteBodySignalInfo = MessageWroteBodyCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageWroteBodyCallback cb
cb'' <- mk_MessageWroteBodyCallback cb'
connectSignalFunPtr obj "wrote-body" cb'' connectMode
data MessageWroteBodyDataSignalInfo
instance SignalInfo MessageWroteBodyDataSignalInfo where
type HaskellCallbackType MessageWroteBodyDataSignalInfo = MessageWroteBodyDataCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageWroteBodyDataCallback cb
cb'' <- mk_MessageWroteBodyDataCallback cb'
connectSignalFunPtr obj "wrote-body-data" cb'' connectMode
data MessageWroteChunkSignalInfo
instance SignalInfo MessageWroteChunkSignalInfo where
type HaskellCallbackType MessageWroteChunkSignalInfo = MessageWroteChunkCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageWroteChunkCallback cb
cb'' <- mk_MessageWroteChunkCallback cb'
connectSignalFunPtr obj "wrote-chunk" cb'' connectMode
data MessageWroteHeadersSignalInfo
instance SignalInfo MessageWroteHeadersSignalInfo where
type HaskellCallbackType MessageWroteHeadersSignalInfo = MessageWroteHeadersCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageWroteHeadersCallback cb
cb'' <- mk_MessageWroteHeadersCallback cb'
connectSignalFunPtr obj "wrote-headers" cb'' connectMode
data MessageWroteInformationalSignalInfo
instance SignalInfo MessageWroteInformationalSignalInfo where
type HaskellCallbackType MessageWroteInformationalSignalInfo = MessageWroteInformationalCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_MessageWroteInformationalCallback cb
cb'' <- mk_MessageWroteInformationalCallback cb'
connectSignalFunPtr obj "wrote-informational" cb'' connectMode
type instance O.SignalList Message = MessageSignalList
type MessageSignalList = ('[ '("contentSniffed", MessageContentSniffedSignalInfo), '("finished", MessageFinishedSignalInfo), '("gotBody", MessageGotBodySignalInfo), '("gotChunk", MessageGotChunkSignalInfo), '("gotHeaders", MessageGotHeadersSignalInfo), '("gotInformational", MessageGotInformationalSignalInfo), '("networkEvent", MessageNetworkEventSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("restarted", MessageRestartedSignalInfo), '("starting", MessageStartingSignalInfo), '("wroteBody", MessageWroteBodySignalInfo), '("wroteBodyData", MessageWroteBodyDataSignalInfo), '("wroteChunk", MessageWroteChunkSignalInfo), '("wroteHeaders", MessageWroteHeadersSignalInfo), '("wroteInformational", MessageWroteInformationalSignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "soup_message_new" soup_message_new ::
CString ->
CString ->
IO (Ptr Message)
messageNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> T.Text
-> m (Maybe Message)
messageNew method uriString = liftIO $ do
method' <- textToCString method
uriString' <- textToCString uriString
result <- soup_message_new method' uriString'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- (wrapObject Message) result'
return result''
freeMem method'
freeMem uriString'
return maybeResult
#if ENABLE_OVERLOADING
#endif
foreign import ccall "soup_message_new_from_uri" soup_message_new_from_uri ::
CString ->
Ptr Soup.URI.URI ->
IO (Ptr Message)
messageNewFromUri ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> Soup.URI.URI
-> m Message
messageNewFromUri method uri = liftIO $ do
method' <- textToCString method
uri' <- unsafeManagedPtrGetPtr uri
result <- soup_message_new_from_uri method' uri'
checkUnexpectedReturnNULL "messageNewFromUri" result
result' <- (wrapObject Message) result
touchManagedPtr uri
freeMem method'
return result'
#if ENABLE_OVERLOADING
#endif
foreign import ccall "soup_message_content_sniffed" soup_message_content_sniffed ::
Ptr Message ->
CString ->
Ptr (GHashTable (Ptr ()) (Ptr ())) ->
IO ()
messageContentSniffed ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> T.Text
-> Map.Map (Ptr ()) (Ptr ())
-> m ()
messageContentSniffed msg contentType params = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
contentType' <- textToCString contentType
let params' = Map.toList params
let params'' = mapFirst ptrPackPtr params'
let params''' = mapSecond ptrPackPtr params''
params'''' <- packGHashTable gDirectHash gDirectEqual Nothing Nothing params'''
soup_message_content_sniffed msg' contentType' params''''
touchManagedPtr msg
freeMem contentType'
unrefGHashTable params''''
return ()
#if ENABLE_OVERLOADING
data MessageContentSniffedMethodInfo
instance (signature ~ (T.Text -> Map.Map (Ptr ()) (Ptr ()) -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageContentSniffedMethodInfo a signature where
overloadedMethod _ = messageContentSniffed
#endif
foreign import ccall "soup_message_disable_feature" soup_message_disable_feature ::
Ptr Message ->
CGType ->
IO ()
messageDisableFeature ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> GType
-> m ()
messageDisableFeature msg featureType = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
let featureType' = gtypeToCGType featureType
soup_message_disable_feature msg' featureType'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageDisableFeatureMethodInfo
instance (signature ~ (GType -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageDisableFeatureMethodInfo a signature where
overloadedMethod _ = messageDisableFeature
#endif
foreign import ccall "soup_message_finished" soup_message_finished ::
Ptr Message ->
IO ()
messageFinished ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageFinished msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_finished msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageFinishedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageFinishedMethodInfo a signature where
overloadedMethod _ = messageFinished
#endif
foreign import ccall "soup_message_get_address" soup_message_get_address ::
Ptr Message ->
IO (Ptr Soup.Address.Address)
messageGetAddress ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m Soup.Address.Address
messageGetAddress msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
result <- soup_message_get_address msg'
checkUnexpectedReturnNULL "messageGetAddress" result
result' <- (newObject Soup.Address.Address) result
touchManagedPtr msg
return result'
#if ENABLE_OVERLOADING
data MessageGetAddressMethodInfo
instance (signature ~ (m Soup.Address.Address), MonadIO m, IsMessage a) => O.MethodInfo MessageGetAddressMethodInfo a signature where
overloadedMethod _ = messageGetAddress
#endif
foreign import ccall "soup_message_get_first_party" soup_message_get_first_party ::
Ptr Message ->
IO (Ptr Soup.URI.URI)
messageGetFirstParty ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m Soup.URI.URI
messageGetFirstParty msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
result <- soup_message_get_first_party msg'
checkUnexpectedReturnNULL "messageGetFirstParty" result
result' <- (newBoxed Soup.URI.URI) result
touchManagedPtr msg
return result'
#if ENABLE_OVERLOADING
data MessageGetFirstPartyMethodInfo
instance (signature ~ (m Soup.URI.URI), MonadIO m, IsMessage a) => O.MethodInfo MessageGetFirstPartyMethodInfo a signature where
overloadedMethod _ = messageGetFirstParty
#endif
foreign import ccall "soup_message_get_flags" soup_message_get_flags ::
Ptr Message ->
IO CUInt
messageGetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m [Soup.Flags.MessageFlags]
messageGetFlags msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
result <- soup_message_get_flags msg'
let result' = wordToGFlags result
touchManagedPtr msg
return result'
#if ENABLE_OVERLOADING
data MessageGetFlagsMethodInfo
instance (signature ~ (m [Soup.Flags.MessageFlags]), MonadIO m, IsMessage a) => O.MethodInfo MessageGetFlagsMethodInfo a signature where
overloadedMethod _ = messageGetFlags
#endif
foreign import ccall "soup_message_get_http_version" soup_message_get_http_version ::
Ptr Message ->
IO CUInt
messageGetHttpVersion ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m Soup.Enums.HTTPVersion
messageGetHttpVersion msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
result <- soup_message_get_http_version msg'
let result' = (toEnum . fromIntegral) result
touchManagedPtr msg
return result'
#if ENABLE_OVERLOADING
data MessageGetHttpVersionMethodInfo
instance (signature ~ (m Soup.Enums.HTTPVersion), MonadIO m, IsMessage a) => O.MethodInfo MessageGetHttpVersionMethodInfo a signature where
overloadedMethod _ = messageGetHttpVersion
#endif
foreign import ccall "soup_message_get_https_status" soup_message_get_https_status ::
Ptr Message ->
Ptr (Ptr Gio.TlsCertificate.TlsCertificate) ->
Ptr CUInt ->
IO CInt
messageGetHttpsStatus ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ((Bool, Gio.TlsCertificate.TlsCertificate, [Gio.Flags.TlsCertificateFlags]))
messageGetHttpsStatus msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
certificate <- allocMem :: IO (Ptr (Ptr Gio.TlsCertificate.TlsCertificate))
errors <- allocMem :: IO (Ptr CUInt)
result <- soup_message_get_https_status msg' certificate errors
let result' = (/= 0) result
certificate' <- peek certificate
certificate'' <- (newObject Gio.TlsCertificate.TlsCertificate) certificate'
errors' <- peek errors
let errors'' = wordToGFlags errors'
touchManagedPtr msg
freeMem certificate
freeMem errors
return (result', certificate'', errors'')
#if ENABLE_OVERLOADING
data MessageGetHttpsStatusMethodInfo
instance (signature ~ (m ((Bool, Gio.TlsCertificate.TlsCertificate, [Gio.Flags.TlsCertificateFlags]))), MonadIO m, IsMessage a) => O.MethodInfo MessageGetHttpsStatusMethodInfo a signature where
overloadedMethod _ = messageGetHttpsStatus
#endif
foreign import ccall "soup_message_get_priority" soup_message_get_priority ::
Ptr Message ->
IO CUInt
messageGetPriority ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m Soup.Enums.MessagePriority
messageGetPriority msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
result <- soup_message_get_priority msg'
let result' = (toEnum . fromIntegral) result
touchManagedPtr msg
return result'
#if ENABLE_OVERLOADING
data MessageGetPriorityMethodInfo
instance (signature ~ (m Soup.Enums.MessagePriority), MonadIO m, IsMessage a) => O.MethodInfo MessageGetPriorityMethodInfo a signature where
overloadedMethod _ = messageGetPriority
#endif
foreign import ccall "soup_message_get_soup_request" soup_message_get_soup_request ::
Ptr Message ->
IO (Ptr Soup.Request.Request)
messageGetSoupRequest ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m Soup.Request.Request
messageGetSoupRequest msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
result <- soup_message_get_soup_request msg'
checkUnexpectedReturnNULL "messageGetSoupRequest" result
result' <- (newObject Soup.Request.Request) result
touchManagedPtr msg
return result'
#if ENABLE_OVERLOADING
data MessageGetSoupRequestMethodInfo
instance (signature ~ (m Soup.Request.Request), MonadIO m, IsMessage a) => O.MethodInfo MessageGetSoupRequestMethodInfo a signature where
overloadedMethod _ = messageGetSoupRequest
#endif
foreign import ccall "soup_message_get_uri" soup_message_get_uri ::
Ptr Message ->
IO (Ptr Soup.URI.URI)
messageGetUri ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m Soup.URI.URI
messageGetUri msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
result <- soup_message_get_uri msg'
checkUnexpectedReturnNULL "messageGetUri" result
result' <- (newBoxed Soup.URI.URI) result
touchManagedPtr msg
return result'
#if ENABLE_OVERLOADING
data MessageGetUriMethodInfo
instance (signature ~ (m Soup.URI.URI), MonadIO m, IsMessage a) => O.MethodInfo MessageGetUriMethodInfo a signature where
overloadedMethod _ = messageGetUri
#endif
foreign import ccall "soup_message_got_body" soup_message_got_body ::
Ptr Message ->
IO ()
messageGotBody ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageGotBody msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_got_body msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageGotBodyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageGotBodyMethodInfo a signature where
overloadedMethod _ = messageGotBody
#endif
foreign import ccall "soup_message_got_chunk" soup_message_got_chunk ::
Ptr Message ->
Ptr Soup.Buffer.Buffer ->
IO ()
messageGotChunk ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Soup.Buffer.Buffer
-> m ()
messageGotChunk msg chunk = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
chunk' <- unsafeManagedPtrGetPtr chunk
soup_message_got_chunk msg' chunk'
touchManagedPtr msg
touchManagedPtr chunk
return ()
#if ENABLE_OVERLOADING
data MessageGotChunkMethodInfo
instance (signature ~ (Soup.Buffer.Buffer -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageGotChunkMethodInfo a signature where
overloadedMethod _ = messageGotChunk
#endif
foreign import ccall "soup_message_got_headers" soup_message_got_headers ::
Ptr Message ->
IO ()
messageGotHeaders ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageGotHeaders msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_got_headers msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageGotHeadersMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageGotHeadersMethodInfo a signature where
overloadedMethod _ = messageGotHeaders
#endif
foreign import ccall "soup_message_got_informational" soup_message_got_informational ::
Ptr Message ->
IO ()
messageGotInformational ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageGotInformational msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_got_informational msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageGotInformationalMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageGotInformationalMethodInfo a signature where
overloadedMethod _ = messageGotInformational
#endif
foreign import ccall "soup_message_is_keepalive" soup_message_is_keepalive ::
Ptr Message ->
IO CInt
messageIsKeepalive ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m Bool
messageIsKeepalive msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
result <- soup_message_is_keepalive msg'
let result' = (/= 0) result
touchManagedPtr msg
return result'
#if ENABLE_OVERLOADING
data MessageIsKeepaliveMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsMessage a) => O.MethodInfo MessageIsKeepaliveMethodInfo a signature where
overloadedMethod _ = messageIsKeepalive
#endif
foreign import ccall "soup_message_restarted" soup_message_restarted ::
Ptr Message ->
IO ()
messageRestarted ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageRestarted msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_restarted msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageRestartedMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageRestartedMethodInfo a signature where
overloadedMethod _ = messageRestarted
#endif
foreign import ccall "soup_message_set_chunk_allocator" soup_message_set_chunk_allocator ::
Ptr Message ->
FunPtr Soup.Callbacks.C_ChunkAllocator ->
Ptr () ->
FunPtr GLib.Callbacks.C_DestroyNotify ->
IO ()
{-# DEPRECATED messageSetChunkAllocator ["'GI.Soup.Objects.Request.Request' provides a much simpler API that lets you","read the response directly into your own buffers without needing to","mess with callbacks, pausing\\/unpausing, etc."] #-}
messageSetChunkAllocator ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Soup.Callbacks.ChunkAllocator
-> m ()
messageSetChunkAllocator msg allocator = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
allocator' <- Soup.Callbacks.mk_ChunkAllocator (Soup.Callbacks.wrap_ChunkAllocator Nothing (Soup.Callbacks.drop_closures_ChunkAllocator allocator))
let userData = castFunPtrToPtr allocator'
let destroyNotify = safeFreeFunPtrPtr
soup_message_set_chunk_allocator msg' allocator' userData destroyNotify
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageSetChunkAllocatorMethodInfo
instance (signature ~ (Soup.Callbacks.ChunkAllocator -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetChunkAllocatorMethodInfo a signature where
overloadedMethod _ = messageSetChunkAllocator
#endif
foreign import ccall "soup_message_set_first_party" soup_message_set_first_party ::
Ptr Message ->
Ptr Soup.URI.URI ->
IO ()
messageSetFirstParty ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Soup.URI.URI
-> m ()
messageSetFirstParty msg firstParty = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
firstParty' <- unsafeManagedPtrGetPtr firstParty
soup_message_set_first_party msg' firstParty'
touchManagedPtr msg
touchManagedPtr firstParty
return ()
#if ENABLE_OVERLOADING
data MessageSetFirstPartyMethodInfo
instance (signature ~ (Soup.URI.URI -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetFirstPartyMethodInfo a signature where
overloadedMethod _ = messageSetFirstParty
#endif
foreign import ccall "soup_message_set_flags" soup_message_set_flags ::
Ptr Message ->
CUInt ->
IO ()
messageSetFlags ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> [Soup.Flags.MessageFlags]
-> m ()
messageSetFlags msg flags = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
let flags' = gflagsToWord flags
soup_message_set_flags msg' flags'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageSetFlagsMethodInfo
instance (signature ~ ([Soup.Flags.MessageFlags] -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetFlagsMethodInfo a signature where
overloadedMethod _ = messageSetFlags
#endif
foreign import ccall "soup_message_set_http_version" soup_message_set_http_version ::
Ptr Message ->
CUInt ->
IO ()
messageSetHttpVersion ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Soup.Enums.HTTPVersion
-> m ()
messageSetHttpVersion msg version = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
let version' = (fromIntegral . fromEnum) version
soup_message_set_http_version msg' version'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageSetHttpVersionMethodInfo
instance (signature ~ (Soup.Enums.HTTPVersion -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetHttpVersionMethodInfo a signature where
overloadedMethod _ = messageSetHttpVersion
#endif
foreign import ccall "soup_message_set_priority" soup_message_set_priority ::
Ptr Message ->
CUInt ->
IO ()
messageSetPriority ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Soup.Enums.MessagePriority
-> m ()
messageSetPriority msg priority = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
let priority' = (fromIntegral . fromEnum) priority
soup_message_set_priority msg' priority'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageSetPriorityMethodInfo
instance (signature ~ (Soup.Enums.MessagePriority -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetPriorityMethodInfo a signature where
overloadedMethod _ = messageSetPriority
#endif
foreign import ccall "soup_message_set_redirect" soup_message_set_redirect ::
Ptr Message ->
Word32 ->
CString ->
IO ()
messageSetRedirect ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Word32
-> T.Text
-> m ()
messageSetRedirect msg statusCode redirectUri = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
redirectUri' <- textToCString redirectUri
soup_message_set_redirect msg' statusCode redirectUri'
touchManagedPtr msg
freeMem redirectUri'
return ()
#if ENABLE_OVERLOADING
data MessageSetRedirectMethodInfo
instance (signature ~ (Word32 -> T.Text -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetRedirectMethodInfo a signature where
overloadedMethod _ = messageSetRedirect
#endif
foreign import ccall "soup_message_set_request" soup_message_set_request ::
Ptr Message ->
CString ->
CUInt ->
Ptr Word8 ->
Word64 ->
IO ()
messageSetRequest ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Maybe (T.Text)
-> Soup.Enums.MemoryUse
-> Maybe (ByteString)
-> m ()
messageSetRequest msg contentType reqUse reqBody = liftIO $ do
let reqLength = case reqBody of
Nothing -> 0
Just jReqBody -> fromIntegral $ B.length jReqBody
msg' <- unsafeManagedPtrCastPtr msg
maybeContentType <- case contentType of
Nothing -> return nullPtr
Just jContentType -> do
jContentType' <- textToCString jContentType
return jContentType'
let reqUse' = (fromIntegral . fromEnum) reqUse
maybeReqBody <- case reqBody of
Nothing -> return nullPtr
Just jReqBody -> do
jReqBody' <- packByteString jReqBody
return jReqBody'
soup_message_set_request msg' maybeContentType reqUse' maybeReqBody reqLength
touchManagedPtr msg
freeMem maybeContentType
freeMem maybeReqBody
return ()
#if ENABLE_OVERLOADING
data MessageSetRequestMethodInfo
instance (signature ~ (Maybe (T.Text) -> Soup.Enums.MemoryUse -> Maybe (ByteString) -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetRequestMethodInfo a signature where
overloadedMethod _ = messageSetRequest
#endif
foreign import ccall "soup_message_set_response" soup_message_set_response ::
Ptr Message ->
CString ->
CUInt ->
Ptr Word8 ->
Word64 ->
IO ()
messageSetResponse ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Maybe (T.Text)
-> Soup.Enums.MemoryUse
-> Maybe (ByteString)
-> m ()
messageSetResponse msg contentType respUse respBody = liftIO $ do
let respLength = case respBody of
Nothing -> 0
Just jRespBody -> fromIntegral $ B.length jRespBody
msg' <- unsafeManagedPtrCastPtr msg
maybeContentType <- case contentType of
Nothing -> return nullPtr
Just jContentType -> do
jContentType' <- textToCString jContentType
return jContentType'
let respUse' = (fromIntegral . fromEnum) respUse
maybeRespBody <- case respBody of
Nothing -> return nullPtr
Just jRespBody -> do
jRespBody' <- packByteString jRespBody
return jRespBody'
soup_message_set_response msg' maybeContentType respUse' maybeRespBody respLength
touchManagedPtr msg
freeMem maybeContentType
freeMem maybeRespBody
return ()
#if ENABLE_OVERLOADING
data MessageSetResponseMethodInfo
instance (signature ~ (Maybe (T.Text) -> Soup.Enums.MemoryUse -> Maybe (ByteString) -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetResponseMethodInfo a signature where
overloadedMethod _ = messageSetResponse
#endif
foreign import ccall "soup_message_set_status" soup_message_set_status ::
Ptr Message ->
Word32 ->
IO ()
messageSetStatus ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Word32
-> m ()
messageSetStatus msg statusCode = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_set_status msg' statusCode
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageSetStatusMethodInfo
instance (signature ~ (Word32 -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetStatusMethodInfo a signature where
overloadedMethod _ = messageSetStatus
#endif
foreign import ccall "soup_message_set_status_full" soup_message_set_status_full ::
Ptr Message ->
Word32 ->
CString ->
IO ()
messageSetStatusFull ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Word32
-> T.Text
-> m ()
messageSetStatusFull msg statusCode reasonPhrase = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
reasonPhrase' <- textToCString reasonPhrase
soup_message_set_status_full msg' statusCode reasonPhrase'
touchManagedPtr msg
freeMem reasonPhrase'
return ()
#if ENABLE_OVERLOADING
data MessageSetStatusFullMethodInfo
instance (signature ~ (Word32 -> T.Text -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetStatusFullMethodInfo a signature where
overloadedMethod _ = messageSetStatusFull
#endif
foreign import ccall "soup_message_set_uri" soup_message_set_uri ::
Ptr Message ->
Ptr Soup.URI.URI ->
IO ()
messageSetUri ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Soup.URI.URI
-> m ()
messageSetUri msg uri = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
uri' <- unsafeManagedPtrGetPtr uri
soup_message_set_uri msg' uri'
touchManagedPtr msg
touchManagedPtr uri
return ()
#if ENABLE_OVERLOADING
data MessageSetUriMethodInfo
instance (signature ~ (Soup.URI.URI -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageSetUriMethodInfo a signature where
overloadedMethod _ = messageSetUri
#endif
foreign import ccall "soup_message_starting" soup_message_starting ::
Ptr Message ->
IO ()
messageStarting ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageStarting msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_starting msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageStartingMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageStartingMethodInfo a signature where
overloadedMethod _ = messageStarting
#endif
foreign import ccall "soup_message_wrote_body" soup_message_wrote_body ::
Ptr Message ->
IO ()
messageWroteBody ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageWroteBody msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_wrote_body msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageWroteBodyMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageWroteBodyMethodInfo a signature where
overloadedMethod _ = messageWroteBody
#endif
foreign import ccall "soup_message_wrote_body_data" soup_message_wrote_body_data ::
Ptr Message ->
Ptr Soup.Buffer.Buffer ->
IO ()
messageWroteBodyData ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> Soup.Buffer.Buffer
-> m ()
messageWroteBodyData msg chunk = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
chunk' <- unsafeManagedPtrGetPtr chunk
soup_message_wrote_body_data msg' chunk'
touchManagedPtr msg
touchManagedPtr chunk
return ()
#if ENABLE_OVERLOADING
data MessageWroteBodyDataMethodInfo
instance (signature ~ (Soup.Buffer.Buffer -> m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageWroteBodyDataMethodInfo a signature where
overloadedMethod _ = messageWroteBodyData
#endif
foreign import ccall "soup_message_wrote_chunk" soup_message_wrote_chunk ::
Ptr Message ->
IO ()
messageWroteChunk ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageWroteChunk msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_wrote_chunk msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageWroteChunkMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageWroteChunkMethodInfo a signature where
overloadedMethod _ = messageWroteChunk
#endif
foreign import ccall "soup_message_wrote_headers" soup_message_wrote_headers ::
Ptr Message ->
IO ()
messageWroteHeaders ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageWroteHeaders msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_wrote_headers msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageWroteHeadersMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageWroteHeadersMethodInfo a signature where
overloadedMethod _ = messageWroteHeaders
#endif
foreign import ccall "soup_message_wrote_informational" soup_message_wrote_informational ::
Ptr Message ->
IO ()
messageWroteInformational ::
(B.CallStack.HasCallStack, MonadIO m, IsMessage a) =>
a
-> m ()
messageWroteInformational msg = liftIO $ do
msg' <- unsafeManagedPtrCastPtr msg
soup_message_wrote_informational msg'
touchManagedPtr msg
return ()
#if ENABLE_OVERLOADING
data MessageWroteInformationalMethodInfo
instance (signature ~ (m ()), MonadIO m, IsMessage a) => O.MethodInfo MessageWroteInformationalMethodInfo a signature where
overloadedMethod _ = messageWroteInformational
#endif