GI.Soup.Objects.Message

Exported types

newtype Message

Constructors

Message (ForeignPtr Message)

Instances

GObject Message

((~) * info (ResolveMessageMethod t Message), MethodInfo * info Message p) => IsLabelProxy t (Message -> p)

type ParentTypes Message

type AttributeList Message

type SignalList Message

class GObject o => MessageK o

Instances

(GObject o, IsDescendantOf Message o) => MessageK o

toMessage :: MessageK o => o -> IO Message

noMessage :: Maybe Message

Methods

messageContentSniffed

data MessageContentSniffedMethodInfo

Instances

((~) * signature (Text -> Map (Ptr ()) (Ptr ()) -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageContentSniffedMethodInfo a signature

messageContentSniffed :: (MonadIO m, MessageK a) => a -> Text -> Map (Ptr ()) (Ptr ()) -> m ()

messageDisableFeature

data MessageDisableFeatureMethodInfo

Instances

((~) * signature (GType -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageDisableFeatureMethodInfo a signature

messageDisableFeature :: (MonadIO m, MessageK a) => a -> GType -> m ()

messageFinished

data MessageFinishedMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageFinishedMethodInfo a signature

messageFinished :: (MonadIO m, MessageK a) => a -> m ()

messageGetAddress

data MessageGetAddressMethodInfo

Instances

((~) * signature (m Address), MonadIO m, MessageK a) => MethodInfo * MessageGetAddressMethodInfo a signature

messageGetAddress :: (MonadIO m, MessageK a) => a -> m Address

messageGetFirstParty

data MessageGetFirstPartyMethodInfo

Instances

((~) * signature (m URI), MonadIO m, MessageK a) => MethodInfo * MessageGetFirstPartyMethodInfo a signature

messageGetFirstParty :: (MonadIO m, MessageK a) => a -> m URI

messageGetFlags

data MessageGetFlagsMethodInfo

Instances

((~) * signature (m [MessageFlags]), MonadIO m, MessageK a) => MethodInfo * MessageGetFlagsMethodInfo a signature

messageGetFlags :: (MonadIO m, MessageK a) => a -> m [MessageFlags]

messageGetHttpVersion

data MessageGetHttpVersionMethodInfo

Instances

((~) * signature (m HTTPVersion), MonadIO m, MessageK a) => MethodInfo * MessageGetHttpVersionMethodInfo a signature

messageGetHttpVersion :: (MonadIO m, MessageK a) => a -> m HTTPVersion

messageGetHttpsStatus

data MessageGetHttpsStatusMethodInfo

Instances

((~) * signature (m (Bool, TlsCertificate, [TlsCertificateFlags])), MonadIO m, MessageK a) => MethodInfo * MessageGetHttpsStatusMethodInfo a signature

messageGetHttpsStatus :: (MonadIO m, MessageK a) => a -> m (Bool, TlsCertificate, [TlsCertificateFlags])

messageGetPriority

data MessageGetPriorityMethodInfo

Instances

((~) * signature (m MessagePriority), MonadIO m, MessageK a) => MethodInfo * MessageGetPriorityMethodInfo a signature

messageGetPriority :: (MonadIO m, MessageK a) => a -> m MessagePriority

messageGetSoupRequest

data MessageGetSoupRequestMethodInfo

Instances

((~) * signature (m Request), MonadIO m, MessageK a) => MethodInfo * MessageGetSoupRequestMethodInfo a signature

messageGetSoupRequest :: (MonadIO m, MessageK a) => a -> m Request

messageGetUri

data MessageGetUriMethodInfo

Instances

((~) * signature (m URI), MonadIO m, MessageK a) => MethodInfo * MessageGetUriMethodInfo a signature

messageGetUri :: (MonadIO m, MessageK a) => a -> m URI

messageGotBody

data MessageGotBodyMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageGotBodyMethodInfo a signature

messageGotBody :: (MonadIO m, MessageK a) => a -> m ()

messageGotChunk

data MessageGotChunkMethodInfo

Instances

((~) * signature (Buffer -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageGotChunkMethodInfo a signature

messageGotChunk :: (MonadIO m, MessageK a) => a -> Buffer -> m ()

messageGotHeaders

data MessageGotHeadersMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageGotHeadersMethodInfo a signature

messageGotHeaders :: (MonadIO m, MessageK a) => a -> m ()

messageGotInformational

data MessageGotInformationalMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageGotInformationalMethodInfo a signature

messageGotInformational :: (MonadIO m, MessageK a) => a -> m ()

messageIsKeepalive

data MessageIsKeepaliveMethodInfo

Instances

((~) * signature (m Bool), MonadIO m, MessageK a) => MethodInfo * MessageIsKeepaliveMethodInfo a signature

messageIsKeepalive :: (MonadIO m, MessageK a) => a -> m Bool

messageNew

messageNew :: MonadIO m => Text -> Text -> m (Maybe Message)

messageNewFromUri

messageNewFromUri :: MonadIO m => Text -> URI -> m Message

messageRestarted

data MessageRestartedMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageRestartedMethodInfo a signature

messageRestarted :: (MonadIO m, MessageK a) => a -> m ()

messageSetChunkAllocator

data MessageSetChunkAllocatorMethodInfo

Instances

((~) * signature (ChunkAllocator -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetChunkAllocatorMethodInfo a signature

messageSetChunkAllocator :: (MonadIO m, MessageK a) => a -> ChunkAllocator -> m ()

Deprecated: #SoupRequest provides a much simpler API that lets youread the response directly into your own buffers without needing tomess with callbacks, pausing/unpausing, etc.

messageSetFirstParty

data MessageSetFirstPartyMethodInfo

Instances

((~) * signature (URI -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetFirstPartyMethodInfo a signature

messageSetFirstParty :: (MonadIO m, MessageK a) => a -> URI -> m ()

messageSetFlags

data MessageSetFlagsMethodInfo

Instances

((~) * signature ([MessageFlags] -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetFlagsMethodInfo a signature

messageSetFlags :: (MonadIO m, MessageK a) => a -> [MessageFlags] -> m ()

messageSetHttpVersion

data MessageSetHttpVersionMethodInfo

Instances

((~) * signature (HTTPVersion -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetHttpVersionMethodInfo a signature

messageSetHttpVersion :: (MonadIO m, MessageK a) => a -> HTTPVersion -> m ()

messageSetPriority

data MessageSetPriorityMethodInfo

Instances

((~) * signature (MessagePriority -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetPriorityMethodInfo a signature

messageSetPriority :: (MonadIO m, MessageK a) => a -> MessagePriority -> m ()

messageSetRedirect

data MessageSetRedirectMethodInfo

Instances

((~) * signature (Word32 -> Text -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetRedirectMethodInfo a signature

messageSetRedirect :: (MonadIO m, MessageK a) => a -> Word32 -> Text -> m ()

messageSetRequest

data MessageSetRequestMethodInfo

Instances

((~) * signature (Maybe Text -> MemoryUse -> Maybe ByteString -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetRequestMethodInfo a signature

messageSetRequest :: (MonadIO m, MessageK a) => a -> Maybe Text -> MemoryUse -> Maybe ByteString -> m ()

messageSetResponse

data MessageSetResponseMethodInfo

Instances

((~) * signature (Maybe Text -> MemoryUse -> Maybe ByteString -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetResponseMethodInfo a signature

messageSetResponse :: (MonadIO m, MessageK a) => a -> Maybe Text -> MemoryUse -> Maybe ByteString -> m ()

messageSetStatus

data MessageSetStatusMethodInfo

Instances

((~) * signature (Word32 -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetStatusMethodInfo a signature

messageSetStatus :: (MonadIO m, MessageK a) => a -> Word32 -> m ()

messageSetStatusFull

data MessageSetStatusFullMethodInfo

Instances

((~) * signature (Word32 -> Text -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetStatusFullMethodInfo a signature

messageSetStatusFull :: (MonadIO m, MessageK a) => a -> Word32 -> Text -> m ()

messageSetUri

data MessageSetUriMethodInfo

Instances

((~) * signature (URI -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageSetUriMethodInfo a signature

messageSetUri :: (MonadIO m, MessageK a) => a -> URI -> m ()

messageStarting

data MessageStartingMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageStartingMethodInfo a signature

messageStarting :: (MonadIO m, MessageK a) => a -> m ()

messageWroteBody

data MessageWroteBodyMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageWroteBodyMethodInfo a signature

messageWroteBody :: (MonadIO m, MessageK a) => a -> m ()

messageWroteBodyData

data MessageWroteBodyDataMethodInfo

Instances

((~) * signature (Buffer -> m ()), MonadIO m, MessageK a) => MethodInfo * MessageWroteBodyDataMethodInfo a signature

messageWroteBodyData :: (MonadIO m, MessageK a) => a -> Buffer -> m ()

messageWroteChunk

data MessageWroteChunkMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageWroteChunkMethodInfo a signature

messageWroteChunk :: (MonadIO m, MessageK a) => a -> m ()

messageWroteHeaders

data MessageWroteHeadersMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageWroteHeadersMethodInfo a signature

messageWroteHeaders :: (MonadIO m, MessageK a) => a -> m ()

messageWroteInformational

data MessageWroteInformationalMethodInfo

Instances

((~) * signature (m ()), MonadIO m, MessageK a) => MethodInfo * MessageWroteInformationalMethodInfo a signature

messageWroteInformational :: (MonadIO m, MessageK a) => a -> m ()

Properties

FirstParty

data MessageFirstPartyPropertyInfo

Instances

AttrInfo MessageFirstPartyPropertyInfo

type AttrLabel MessageFirstPartyPropertyInfo = "first-party"

type AttrGetType MessageFirstPartyPropertyInfo = URI

type AttrBaseTypeConstraint MessageFirstPartyPropertyInfo = MessageK

type AttrSetTypeConstraint MessageFirstPartyPropertyInfo = * ~ URI

type AttrAllowedOps MessageFirstPartyPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMessageFirstParty :: URI -> IO ([Char], GValue)

getMessageFirstParty :: (MonadIO m, MessageK o) => o -> m URI

messageFirstParty :: AttrLabelProxy "firstParty"

setMessageFirstParty :: (MonadIO m, MessageK o) => o -> URI -> m ()

Flags

data MessageFlagsPropertyInfo

Instances

AttrInfo MessageFlagsPropertyInfo

type AttrLabel MessageFlagsPropertyInfo = "flags"

type AttrGetType MessageFlagsPropertyInfo = [MessageFlags]

type AttrBaseTypeConstraint MessageFlagsPropertyInfo = MessageK

type AttrSetTypeConstraint MessageFlagsPropertyInfo = * ~ [MessageFlags]

type AttrAllowedOps MessageFlagsPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMessageFlags :: [MessageFlags] -> IO ([Char], GValue)

getMessageFlags :: (MonadIO m, MessageK o) => o -> m [MessageFlags]

messageFlags :: AttrLabelProxy "flags"

setMessageFlags :: (MonadIO m, MessageK o) => o -> [MessageFlags] -> m ()

HttpVersion

data MessageHttpVersionPropertyInfo

Instances

AttrInfo MessageHttpVersionPropertyInfo

type AttrLabel MessageHttpVersionPropertyInfo = "http-version"

type AttrGetType MessageHttpVersionPropertyInfo = HTTPVersion

type AttrBaseTypeConstraint MessageHttpVersionPropertyInfo = MessageK

type AttrSetTypeConstraint MessageHttpVersionPropertyInfo = * ~ HTTPVersion

type AttrAllowedOps MessageHttpVersionPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMessageHttpVersion :: HTTPVersion -> IO ([Char], GValue)

getMessageHttpVersion :: (MonadIO m, MessageK o) => o -> m HTTPVersion

messageHttpVersion :: AttrLabelProxy "httpVersion"

setMessageHttpVersion :: (MonadIO m, MessageK o) => o -> HTTPVersion -> m ()

Method

data MessageMethodPropertyInfo

Instances

AttrInfo MessageMethodPropertyInfo

type AttrLabel MessageMethodPropertyInfo = "method"

type AttrGetType MessageMethodPropertyInfo = Maybe Text

type AttrBaseTypeConstraint MessageMethodPropertyInfo = MessageK

type AttrSetTypeConstraint MessageMethodPropertyInfo = * ~ Text

type AttrAllowedOps MessageMethodPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearMessageMethod :: (MonadIO m, MessageK o) => o -> m ()

constructMessageMethod :: Text -> IO ([Char], GValue)

getMessageMethod :: (MonadIO m, MessageK o) => o -> m (Maybe Text)

messageMethod :: AttrLabelProxy "method"

setMessageMethod :: (MonadIO m, MessageK o) => o -> Text -> m ()

Priority

data MessagePriorityPropertyInfo

Instances

AttrInfo MessagePriorityPropertyInfo

type AttrLabel MessagePriorityPropertyInfo = "priority"

type AttrGetType MessagePriorityPropertyInfo = MessagePriority

type AttrBaseTypeConstraint MessagePriorityPropertyInfo = MessageK

type AttrSetTypeConstraint MessagePriorityPropertyInfo = * ~ MessagePriority

type AttrAllowedOps MessagePriorityPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMessagePriority :: MessagePriority -> IO ([Char], GValue)

getMessagePriority :: (MonadIO m, MessageK o) => o -> m MessagePriority

messagePriority :: AttrLabelProxy "priority"

setMessagePriority :: (MonadIO m, MessageK o) => o -> MessagePriority -> m ()

ReasonPhrase

data MessageReasonPhrasePropertyInfo

Instances

AttrInfo MessageReasonPhrasePropertyInfo

type AttrLabel MessageReasonPhrasePropertyInfo = "reason-phrase"

type AttrGetType MessageReasonPhrasePropertyInfo = Maybe Text

type AttrBaseTypeConstraint MessageReasonPhrasePropertyInfo = MessageK

type AttrSetTypeConstraint MessageReasonPhrasePropertyInfo = * ~ Text

type AttrAllowedOps MessageReasonPhrasePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearMessageReasonPhrase :: (MonadIO m, MessageK o) => o -> m ()

constructMessageReasonPhrase :: Text -> IO ([Char], GValue)

getMessageReasonPhrase :: (MonadIO m, MessageK o) => o -> m (Maybe Text)

messageReasonPhrase :: AttrLabelProxy "reasonPhrase"

setMessageReasonPhrase :: (MonadIO m, MessageK o) => o -> Text -> m ()

RequestBody

data MessageRequestBodyPropertyInfo

Instances

AttrInfo MessageRequestBodyPropertyInfo

type AttrLabel MessageRequestBodyPropertyInfo = "request-body"

type AttrGetType MessageRequestBodyPropertyInfo = Maybe MessageBody

type AttrBaseTypeConstraint MessageRequestBodyPropertyInfo = MessageK

type AttrSetTypeConstraint MessageRequestBodyPropertyInfo = * ~ ()

type AttrAllowedOps MessageRequestBodyPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getMessageRequestBody :: (MonadIO m, MessageK o) => o -> m (Maybe MessageBody)

messageRequestBody :: AttrLabelProxy "requestBody"

RequestBodyData

data MessageRequestBodyDataPropertyInfo

Instances

AttrInfo MessageRequestBodyDataPropertyInfo

type AttrLabel MessageRequestBodyDataPropertyInfo = "request-body-data"

type AttrGetType MessageRequestBodyDataPropertyInfo = Maybe Bytes

type AttrBaseTypeConstraint MessageRequestBodyDataPropertyInfo = MessageK

type AttrSetTypeConstraint MessageRequestBodyDataPropertyInfo = * ~ ()

type AttrAllowedOps MessageRequestBodyDataPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getMessageRequestBodyData :: (MonadIO m, MessageK o) => o -> m (Maybe Bytes)

messageRequestBodyData :: AttrLabelProxy "requestBodyData"

RequestHeaders

data MessageRequestHeadersPropertyInfo

Instances

AttrInfo MessageRequestHeadersPropertyInfo

type AttrLabel MessageRequestHeadersPropertyInfo = "request-headers"

type AttrGetType MessageRequestHeadersPropertyInfo = Maybe MessageHeaders

type AttrBaseTypeConstraint MessageRequestHeadersPropertyInfo = MessageK

type AttrSetTypeConstraint MessageRequestHeadersPropertyInfo = * ~ ()

type AttrAllowedOps MessageRequestHeadersPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getMessageRequestHeaders :: (MonadIO m, MessageK o) => o -> m (Maybe MessageHeaders)

messageRequestHeaders :: AttrLabelProxy "requestHeaders"

ResponseBody

data MessageResponseBodyPropertyInfo

Instances

AttrInfo MessageResponseBodyPropertyInfo

type AttrLabel MessageResponseBodyPropertyInfo = "response-body"

type AttrGetType MessageResponseBodyPropertyInfo = Maybe MessageBody

type AttrBaseTypeConstraint MessageResponseBodyPropertyInfo = MessageK

type AttrSetTypeConstraint MessageResponseBodyPropertyInfo = * ~ ()

type AttrAllowedOps MessageResponseBodyPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getMessageResponseBody :: (MonadIO m, MessageK o) => o -> m (Maybe MessageBody)

messageResponseBody :: AttrLabelProxy "responseBody"

ResponseBodyData

data MessageResponseBodyDataPropertyInfo

Instances

AttrInfo MessageResponseBodyDataPropertyInfo

type AttrLabel MessageResponseBodyDataPropertyInfo = "response-body-data"

type AttrGetType MessageResponseBodyDataPropertyInfo = Maybe Bytes

type AttrBaseTypeConstraint MessageResponseBodyDataPropertyInfo = MessageK

type AttrSetTypeConstraint MessageResponseBodyDataPropertyInfo = * ~ ()

type AttrAllowedOps MessageResponseBodyDataPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getMessageResponseBodyData :: (MonadIO m, MessageK o) => o -> m (Maybe Bytes)

messageResponseBodyData :: AttrLabelProxy "responseBodyData"

ResponseHeaders

data MessageResponseHeadersPropertyInfo

Instances

AttrInfo MessageResponseHeadersPropertyInfo

type AttrLabel MessageResponseHeadersPropertyInfo = "response-headers"

type AttrGetType MessageResponseHeadersPropertyInfo = Maybe MessageHeaders

type AttrBaseTypeConstraint MessageResponseHeadersPropertyInfo = MessageK

type AttrSetTypeConstraint MessageResponseHeadersPropertyInfo = * ~ ()

type AttrAllowedOps MessageResponseHeadersPropertyInfo = (:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))

getMessageResponseHeaders :: (MonadIO m, MessageK o) => o -> m (Maybe MessageHeaders)

messageResponseHeaders :: AttrLabelProxy "responseHeaders"

ServerSide

data MessageServerSidePropertyInfo

Instances

AttrInfo MessageServerSidePropertyInfo

type AttrLabel MessageServerSidePropertyInfo = "server-side"

type AttrGetType MessageServerSidePropertyInfo = Bool

type AttrBaseTypeConstraint MessageServerSidePropertyInfo = MessageK

type AttrSetTypeConstraint MessageServerSidePropertyInfo = * ~ Bool

type AttrAllowedOps MessageServerSidePropertyInfo = (:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag))

constructMessageServerSide :: Bool -> IO ([Char], GValue)

getMessageServerSide :: (MonadIO m, MessageK o) => o -> m Bool

messageServerSide :: AttrLabelProxy "serverSide"

StatusCode

data MessageStatusCodePropertyInfo

Instances

AttrInfo MessageStatusCodePropertyInfo

type AttrLabel MessageStatusCodePropertyInfo = "status-code"

type AttrGetType MessageStatusCodePropertyInfo = Word32

type AttrBaseTypeConstraint MessageStatusCodePropertyInfo = MessageK

type AttrSetTypeConstraint MessageStatusCodePropertyInfo = * ~ Word32

type AttrAllowedOps MessageStatusCodePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMessageStatusCode :: Word32 -> IO ([Char], GValue)

getMessageStatusCode :: (MonadIO m, MessageK o) => o -> m Word32

messageStatusCode :: AttrLabelProxy "statusCode"

setMessageStatusCode :: (MonadIO m, MessageK o) => o -> Word32 -> m ()

TlsCertificate

data MessageTlsCertificatePropertyInfo

Instances

AttrInfo MessageTlsCertificatePropertyInfo

type AttrLabel MessageTlsCertificatePropertyInfo = "tls-certificate"

type AttrGetType MessageTlsCertificatePropertyInfo = Maybe TlsCertificate

type AttrBaseTypeConstraint MessageTlsCertificatePropertyInfo = MessageK

type AttrSetTypeConstraint MessageTlsCertificatePropertyInfo = TlsCertificateK

type AttrAllowedOps MessageTlsCertificatePropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ((:) AttrOpTag AttrClear ([] AttrOpTag))))

clearMessageTlsCertificate :: (MonadIO m, MessageK o) => o -> m ()

constructMessageTlsCertificate :: TlsCertificateK a => a -> IO ([Char], GValue)

getMessageTlsCertificate :: (MonadIO m, MessageK o) => o -> m (Maybe TlsCertificate)

messageTlsCertificate :: AttrLabelProxy "tlsCertificate"

setMessageTlsCertificate :: (MonadIO m, MessageK o, TlsCertificateK a) => o -> a -> m ()

TlsErrors

data MessageTlsErrorsPropertyInfo

Instances

AttrInfo MessageTlsErrorsPropertyInfo

type AttrLabel MessageTlsErrorsPropertyInfo = "tls-errors"

type AttrGetType MessageTlsErrorsPropertyInfo = [TlsCertificateFlags]

type AttrBaseTypeConstraint MessageTlsErrorsPropertyInfo = MessageK

type AttrSetTypeConstraint MessageTlsErrorsPropertyInfo = * ~ [TlsCertificateFlags]

type AttrAllowedOps MessageTlsErrorsPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMessageTlsErrors :: [TlsCertificateFlags] -> IO ([Char], GValue)

getMessageTlsErrors :: (MonadIO m, MessageK o) => o -> m [TlsCertificateFlags]

messageTlsErrors :: AttrLabelProxy "tlsErrors"

setMessageTlsErrors :: (MonadIO m, MessageK o) => o -> [TlsCertificateFlags] -> m ()

Uri

data MessageUriPropertyInfo

Instances

AttrInfo MessageUriPropertyInfo

type AttrLabel MessageUriPropertyInfo = "uri"

type AttrGetType MessageUriPropertyInfo = URI

type AttrBaseTypeConstraint MessageUriPropertyInfo = MessageK

type AttrSetTypeConstraint MessageUriPropertyInfo = * ~ URI

type AttrAllowedOps MessageUriPropertyInfo = (:) AttrOpTag AttrSet ((:) AttrOpTag AttrConstruct ((:) AttrOpTag AttrGet ([] AttrOpTag)))

constructMessageUri :: URI -> IO ([Char], GValue)

getMessageUri :: (MonadIO m, MessageK o) => o -> m URI

messageUri :: AttrLabelProxy "uri"

setMessageUri :: (MonadIO m, MessageK o) => o -> URI -> m ()

Signals

ContentSniffed

type MessageContentSniffedCallback = Text -> Map Text Text -> IO ()

type MessageContentSniffedCallbackC = Ptr () -> CString -> Ptr (GHashTable CString CString) -> Ptr () -> IO ()

data MessageContentSniffedSignalInfo

Instances

SignalInfo MessageContentSniffedSignalInfo

type HaskellCallbackType MessageContentSniffedSignalInfo = MessageContentSniffedCallback

afterMessageContentSniffed :: (GObject a, MonadIO m) => a -> MessageContentSniffedCallback -> m SignalHandlerId

messageContentSniffedCallbackWrapper :: MessageContentSniffedCallback -> Ptr () -> CString -> Ptr (GHashTable CString CString) -> Ptr () -> IO ()

messageContentSniffedClosure :: MessageContentSniffedCallback -> IO Closure

mkMessageContentSniffedCallback :: MessageContentSniffedCallbackC -> IO (FunPtr MessageContentSniffedCallbackC)

noMessageContentSniffedCallback :: Maybe MessageContentSniffedCallback

onMessageContentSniffed :: (GObject a, MonadIO m) => a -> MessageContentSniffedCallback -> m SignalHandlerId

Finished

type MessageFinishedCallback = IO ()

type MessageFinishedCallbackC = Ptr () -> Ptr () -> IO ()

data MessageFinishedSignalInfo

Instances

SignalInfo MessageFinishedSignalInfo

type HaskellCallbackType MessageFinishedSignalInfo = MessageFinishedCallback

afterMessageFinished :: (GObject a, MonadIO m) => a -> MessageFinishedCallback -> m SignalHandlerId

messageFinishedCallbackWrapper :: MessageFinishedCallback -> Ptr () -> Ptr () -> IO ()

messageFinishedClosure :: MessageFinishedCallback -> IO Closure

mkMessageFinishedCallback :: MessageFinishedCallbackC -> IO (FunPtr MessageFinishedCallbackC)

noMessageFinishedCallback :: Maybe MessageFinishedCallback

onMessageFinished :: (GObject a, MonadIO m) => a -> MessageFinishedCallback -> m SignalHandlerId

GotBody

type MessageGotBodyCallback = IO ()

type MessageGotBodyCallbackC = Ptr () -> Ptr () -> IO ()

data MessageGotBodySignalInfo

Instances

SignalInfo MessageGotBodySignalInfo

type HaskellCallbackType MessageGotBodySignalInfo = MessageGotBodyCallback

afterMessageGotBody :: (GObject a, MonadIO m) => a -> MessageGotBodyCallback -> m SignalHandlerId

messageGotBodyCallbackWrapper :: MessageGotBodyCallback -> Ptr () -> Ptr () -> IO ()

messageGotBodyClosure :: MessageGotBodyCallback -> IO Closure

mkMessageGotBodyCallback :: MessageGotBodyCallbackC -> IO (FunPtr MessageGotBodyCallbackC)

noMessageGotBodyCallback :: Maybe MessageGotBodyCallback

onMessageGotBody :: (GObject a, MonadIO m) => a -> MessageGotBodyCallback -> m SignalHandlerId

GotChunk

type MessageGotChunkCallback = Buffer -> IO ()

type MessageGotChunkCallbackC = Ptr () -> Ptr Buffer -> Ptr () -> IO ()

data MessageGotChunkSignalInfo

Instances

SignalInfo MessageGotChunkSignalInfo

type HaskellCallbackType MessageGotChunkSignalInfo = MessageGotChunkCallback

afterMessageGotChunk :: (GObject a, MonadIO m) => a -> MessageGotChunkCallback -> m SignalHandlerId

messageGotChunkCallbackWrapper :: MessageGotChunkCallback -> Ptr () -> Ptr Buffer -> Ptr () -> IO ()

messageGotChunkClosure :: MessageGotChunkCallback -> IO Closure

mkMessageGotChunkCallback :: MessageGotChunkCallbackC -> IO (FunPtr MessageGotChunkCallbackC)

noMessageGotChunkCallback :: Maybe MessageGotChunkCallback

onMessageGotChunk :: (GObject a, MonadIO m) => a -> MessageGotChunkCallback -> m SignalHandlerId

GotHeaders

type MessageGotHeadersCallback = IO ()

type MessageGotHeadersCallbackC = Ptr () -> Ptr () -> IO ()

data MessageGotHeadersSignalInfo

Instances

SignalInfo MessageGotHeadersSignalInfo

type HaskellCallbackType MessageGotHeadersSignalInfo = MessageGotHeadersCallback

afterMessageGotHeaders :: (GObject a, MonadIO m) => a -> MessageGotHeadersCallback -> m SignalHandlerId

messageGotHeadersCallbackWrapper :: MessageGotHeadersCallback -> Ptr () -> Ptr () -> IO ()

messageGotHeadersClosure :: MessageGotHeadersCallback -> IO Closure

mkMessageGotHeadersCallback :: MessageGotHeadersCallbackC -> IO (FunPtr MessageGotHeadersCallbackC)

noMessageGotHeadersCallback :: Maybe MessageGotHeadersCallback

onMessageGotHeaders :: (GObject a, MonadIO m) => a -> MessageGotHeadersCallback -> m SignalHandlerId

GotInformational

type MessageGotInformationalCallback = IO ()

type MessageGotInformationalCallbackC = Ptr () -> Ptr () -> IO ()

data MessageGotInformationalSignalInfo

Instances

SignalInfo MessageGotInformationalSignalInfo

type HaskellCallbackType MessageGotInformationalSignalInfo = MessageGotInformationalCallback

afterMessageGotInformational :: (GObject a, MonadIO m) => a -> MessageGotInformationalCallback -> m SignalHandlerId

messageGotInformationalCallbackWrapper :: MessageGotInformationalCallback -> Ptr () -> Ptr () -> IO ()

messageGotInformationalClosure :: MessageGotInformationalCallback -> IO Closure

mkMessageGotInformationalCallback :: MessageGotInformationalCallbackC -> IO (FunPtr MessageGotInformationalCallbackC)

noMessageGotInformationalCallback :: Maybe MessageGotInformationalCallback

onMessageGotInformational :: (GObject a, MonadIO m) => a -> MessageGotInformationalCallback -> m SignalHandlerId

NetworkEvent

type MessageNetworkEventCallback = SocketClientEvent -> IOStream -> IO ()

type MessageNetworkEventCallbackC = Ptr () -> CUInt -> Ptr IOStream -> Ptr () -> IO ()

data MessageNetworkEventSignalInfo

Instances

SignalInfo MessageNetworkEventSignalInfo

type HaskellCallbackType MessageNetworkEventSignalInfo = MessageNetworkEventCallback

afterMessageNetworkEvent :: (GObject a, MonadIO m) => a -> MessageNetworkEventCallback -> m SignalHandlerId

messageNetworkEventCallbackWrapper :: MessageNetworkEventCallback -> Ptr () -> CUInt -> Ptr IOStream -> Ptr () -> IO ()

messageNetworkEventClosure :: MessageNetworkEventCallback -> IO Closure

mkMessageNetworkEventCallback :: MessageNetworkEventCallbackC -> IO (FunPtr MessageNetworkEventCallbackC)

noMessageNetworkEventCallback :: Maybe MessageNetworkEventCallback

onMessageNetworkEvent :: (GObject a, MonadIO m) => a -> MessageNetworkEventCallback -> m SignalHandlerId

Restarted

type MessageRestartedCallback = IO ()

type MessageRestartedCallbackC = Ptr () -> Ptr () -> IO ()

data MessageRestartedSignalInfo

Instances

SignalInfo MessageRestartedSignalInfo

type HaskellCallbackType MessageRestartedSignalInfo = MessageRestartedCallback

afterMessageRestarted :: (GObject a, MonadIO m) => a -> MessageRestartedCallback -> m SignalHandlerId

messageRestartedCallbackWrapper :: MessageRestartedCallback -> Ptr () -> Ptr () -> IO ()

messageRestartedClosure :: MessageRestartedCallback -> IO Closure

mkMessageRestartedCallback :: MessageRestartedCallbackC -> IO (FunPtr MessageRestartedCallbackC)

noMessageRestartedCallback :: Maybe MessageRestartedCallback

onMessageRestarted :: (GObject a, MonadIO m) => a -> MessageRestartedCallback -> m SignalHandlerId

Starting

type MessageStartingCallback = IO ()

type MessageStartingCallbackC = Ptr () -> Ptr () -> IO ()

data MessageStartingSignalInfo

Instances

SignalInfo MessageStartingSignalInfo

type HaskellCallbackType MessageStartingSignalInfo = MessageStartingCallback

afterMessageStarting :: (GObject a, MonadIO m) => a -> MessageStartingCallback -> m SignalHandlerId

messageStartingCallbackWrapper :: MessageStartingCallback -> Ptr () -> Ptr () -> IO ()

messageStartingClosure :: MessageStartingCallback -> IO Closure

mkMessageStartingCallback :: MessageStartingCallbackC -> IO (FunPtr MessageStartingCallbackC)

noMessageStartingCallback :: Maybe MessageStartingCallback

onMessageStarting :: (GObject a, MonadIO m) => a -> MessageStartingCallback -> m SignalHandlerId

WroteBody

type MessageWroteBodyCallback = IO ()

type MessageWroteBodyCallbackC = Ptr () -> Ptr () -> IO ()

data MessageWroteBodySignalInfo

Instances

SignalInfo MessageWroteBodySignalInfo

type HaskellCallbackType MessageWroteBodySignalInfo = MessageWroteBodyCallback

afterMessageWroteBody :: (GObject a, MonadIO m) => a -> MessageWroteBodyCallback -> m SignalHandlerId

messageWroteBodyCallbackWrapper :: MessageWroteBodyCallback -> Ptr () -> Ptr () -> IO ()

messageWroteBodyClosure :: MessageWroteBodyCallback -> IO Closure

mkMessageWroteBodyCallback :: MessageWroteBodyCallbackC -> IO (FunPtr MessageWroteBodyCallbackC)

noMessageWroteBodyCallback :: Maybe MessageWroteBodyCallback

onMessageWroteBody :: (GObject a, MonadIO m) => a -> MessageWroteBodyCallback -> m SignalHandlerId

WroteBodyData

type MessageWroteBodyDataCallback = Buffer -> IO ()

type MessageWroteBodyDataCallbackC = Ptr () -> Ptr Buffer -> Ptr () -> IO ()

data MessageWroteBodyDataSignalInfo

Instances

SignalInfo MessageWroteBodyDataSignalInfo

type HaskellCallbackType MessageWroteBodyDataSignalInfo = MessageWroteBodyDataCallback

afterMessageWroteBodyData :: (GObject a, MonadIO m) => a -> MessageWroteBodyDataCallback -> m SignalHandlerId

messageWroteBodyDataCallbackWrapper :: MessageWroteBodyDataCallback -> Ptr () -> Ptr Buffer -> Ptr () -> IO ()

messageWroteBodyDataClosure :: MessageWroteBodyDataCallback -> IO Closure

mkMessageWroteBodyDataCallback :: MessageWroteBodyDataCallbackC -> IO (FunPtr MessageWroteBodyDataCallbackC)

noMessageWroteBodyDataCallback :: Maybe MessageWroteBodyDataCallback

onMessageWroteBodyData :: (GObject a, MonadIO m) => a -> MessageWroteBodyDataCallback -> m SignalHandlerId

WroteChunk

type MessageWroteChunkCallback = IO ()

type MessageWroteChunkCallbackC = Ptr () -> Ptr () -> IO ()

data MessageWroteChunkSignalInfo

Instances

SignalInfo MessageWroteChunkSignalInfo

type HaskellCallbackType MessageWroteChunkSignalInfo = MessageWroteChunkCallback

afterMessageWroteChunk :: (GObject a, MonadIO m) => a -> MessageWroteChunkCallback -> m SignalHandlerId

messageWroteChunkCallbackWrapper :: MessageWroteChunkCallback -> Ptr () -> Ptr () -> IO ()

messageWroteChunkClosure :: MessageWroteChunkCallback -> IO Closure

mkMessageWroteChunkCallback :: MessageWroteChunkCallbackC -> IO (FunPtr MessageWroteChunkCallbackC)

noMessageWroteChunkCallback :: Maybe MessageWroteChunkCallback

onMessageWroteChunk :: (GObject a, MonadIO m) => a -> MessageWroteChunkCallback -> m SignalHandlerId

WroteHeaders

type MessageWroteHeadersCallback = IO ()

type MessageWroteHeadersCallbackC = Ptr () -> Ptr () -> IO ()

data MessageWroteHeadersSignalInfo

Instances

SignalInfo MessageWroteHeadersSignalInfo

type HaskellCallbackType MessageWroteHeadersSignalInfo = MessageWroteHeadersCallback

afterMessageWroteHeaders :: (GObject a, MonadIO m) => a -> MessageWroteHeadersCallback -> m SignalHandlerId

messageWroteHeadersCallbackWrapper :: MessageWroteHeadersCallback -> Ptr () -> Ptr () -> IO ()

messageWroteHeadersClosure :: MessageWroteHeadersCallback -> IO Closure

mkMessageWroteHeadersCallback :: MessageWroteHeadersCallbackC -> IO (FunPtr MessageWroteHeadersCallbackC)

noMessageWroteHeadersCallback :: Maybe MessageWroteHeadersCallback

onMessageWroteHeaders :: (GObject a, MonadIO m) => a -> MessageWroteHeadersCallback -> m SignalHandlerId

WroteInformational

type MessageWroteInformationalCallback = IO ()

type MessageWroteInformationalCallbackC = Ptr () -> Ptr () -> IO ()

data MessageWroteInformationalSignalInfo

Instances

SignalInfo MessageWroteInformationalSignalInfo

type HaskellCallbackType MessageWroteInformationalSignalInfo = MessageWroteInformationalCallback

afterMessageWroteInformational :: (GObject a, MonadIO m) => a -> MessageWroteInformationalCallback -> m SignalHandlerId

messageWroteInformationalCallbackWrapper :: MessageWroteInformationalCallback -> Ptr () -> Ptr () -> IO ()

messageWroteInformationalClosure :: MessageWroteInformationalCallback -> IO Closure

mkMessageWroteInformationalCallback :: MessageWroteInformationalCallbackC -> IO (FunPtr MessageWroteInformationalCallbackC)

noMessageWroteInformationalCallback :: Maybe MessageWroteInformationalCallback

onMessageWroteInformational :: (GObject a, MonadIO m) => a -> MessageWroteInformationalCallback -> m SignalHandlerId