{-# LANGUAGE ImplicitParams, RankNTypes, TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- An HTTP server request and response pair.
-- 
-- A SoupServerMessage represents an HTTP message that is being sent or
-- received on a [class/@server@/].
-- 
-- [class/@server@/] will create @SoupServerMessage@s automatically for
-- incoming requests, which your application will receive via handlers.
-- 
-- Note that libsoup\'s terminology here does not quite match the HTTP
-- specification: in RFC 2616, an \"HTTP-message\" is *either* a Request, *or* a
-- Response. In libsoup, a t'GI.Soup.Objects.ServerMessage.ServerMessage' combines both the request and the
-- response.

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

module GI.Soup.Objects.ServerMessage
    ( 

-- * Exported types
    ServerMessage(..)                       ,
    IsServerMessage                         ,
    toServerMessage                         ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [isOptionsPing]("GI.Soup.Objects.ServerMessage#g:method:isOptionsPing"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [pause]("GI.Soup.Objects.ServerMessage#g:method:pause"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealConnection]("GI.Soup.Objects.ServerMessage#g:method:stealConnection"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unpause]("GI.Soup.Objects.ServerMessage#g:method:unpause"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getHttpVersion]("GI.Soup.Objects.ServerMessage#g:method:getHttpVersion"), [getLocalAddress]("GI.Soup.Objects.ServerMessage#g:method:getLocalAddress"), [getMethod]("GI.Soup.Objects.ServerMessage#g:method:getMethod"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getReasonPhrase]("GI.Soup.Objects.ServerMessage#g:method:getReasonPhrase"), [getRemoteAddress]("GI.Soup.Objects.ServerMessage#g:method:getRemoteAddress"), [getRemoteHost]("GI.Soup.Objects.ServerMessage#g:method:getRemoteHost"), [getRequestBody]("GI.Soup.Objects.ServerMessage#g:method:getRequestBody"), [getRequestHeaders]("GI.Soup.Objects.ServerMessage#g:method:getRequestHeaders"), [getResponseBody]("GI.Soup.Objects.ServerMessage#g:method:getResponseBody"), [getResponseHeaders]("GI.Soup.Objects.ServerMessage#g:method:getResponseHeaders"), [getSocket]("GI.Soup.Objects.ServerMessage#g:method:getSocket"), [getStatus]("GI.Soup.Objects.ServerMessage#g:method:getStatus"), [getTlsPeerCertificate]("GI.Soup.Objects.ServerMessage#g:method:getTlsPeerCertificate"), [getTlsPeerCertificateErrors]("GI.Soup.Objects.ServerMessage#g:method:getTlsPeerCertificateErrors"), [getUri]("GI.Soup.Objects.ServerMessage#g:method:getUri").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setHttpVersion]("GI.Soup.Objects.ServerMessage#g:method:setHttpVersion"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty"), [setRedirect]("GI.Soup.Objects.ServerMessage#g:method:setRedirect"), [setResponse]("GI.Soup.Objects.ServerMessage#g:method:setResponse"), [setStatus]("GI.Soup.Objects.ServerMessage#g:method:setStatus").

#if defined(ENABLE_OVERLOADING)
    ResolveServerMessageMethod              ,
#endif

-- ** getHttpVersion #method:getHttpVersion#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetHttpVersionMethodInfo   ,
#endif
    serverMessageGetHttpVersion             ,


-- ** getLocalAddress #method:getLocalAddress#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetLocalAddressMethodInfo  ,
#endif
    serverMessageGetLocalAddress            ,


-- ** getMethod #method:getMethod#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetMethodMethodInfo        ,
#endif
    serverMessageGetMethod                  ,


-- ** getReasonPhrase #method:getReasonPhrase#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetReasonPhraseMethodInfo  ,
#endif
    serverMessageGetReasonPhrase            ,


-- ** getRemoteAddress #method:getRemoteAddress#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetRemoteAddressMethodInfo ,
#endif
    serverMessageGetRemoteAddress           ,


-- ** getRemoteHost #method:getRemoteHost#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetRemoteHostMethodInfo    ,
#endif
    serverMessageGetRemoteHost              ,


-- ** getRequestBody #method:getRequestBody#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetRequestBodyMethodInfo   ,
#endif
    serverMessageGetRequestBody             ,


-- ** getRequestHeaders #method:getRequestHeaders#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetRequestHeadersMethodInfo,
#endif
    serverMessageGetRequestHeaders          ,


-- ** getResponseBody #method:getResponseBody#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetResponseBodyMethodInfo  ,
#endif
    serverMessageGetResponseBody            ,


-- ** getResponseHeaders #method:getResponseHeaders#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetResponseHeadersMethodInfo,
#endif
    serverMessageGetResponseHeaders         ,


-- ** getSocket #method:getSocket#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetSocketMethodInfo        ,
#endif
    serverMessageGetSocket                  ,


-- ** getStatus #method:getStatus#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetStatusMethodInfo        ,
#endif
    serverMessageGetStatus                  ,


-- ** getTlsPeerCertificate #method:getTlsPeerCertificate#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetTlsPeerCertificateMethodInfo,
#endif
    serverMessageGetTlsPeerCertificate      ,


-- ** getTlsPeerCertificateErrors #method:getTlsPeerCertificateErrors#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetTlsPeerCertificateErrorsMethodInfo,
#endif
    serverMessageGetTlsPeerCertificateErrors,


-- ** getUri #method:getUri#

#if defined(ENABLE_OVERLOADING)
    ServerMessageGetUriMethodInfo           ,
#endif
    serverMessageGetUri                     ,


-- ** isOptionsPing #method:isOptionsPing#

#if defined(ENABLE_OVERLOADING)
    ServerMessageIsOptionsPingMethodInfo    ,
#endif
    serverMessageIsOptionsPing              ,


-- ** pause #method:pause#

#if defined(ENABLE_OVERLOADING)
    ServerMessagePauseMethodInfo            ,
#endif
    serverMessagePause                      ,


-- ** setHttpVersion #method:setHttpVersion#

#if defined(ENABLE_OVERLOADING)
    ServerMessageSetHttpVersionMethodInfo   ,
#endif
    serverMessageSetHttpVersion             ,


-- ** setRedirect #method:setRedirect#

#if defined(ENABLE_OVERLOADING)
    ServerMessageSetRedirectMethodInfo      ,
#endif
    serverMessageSetRedirect                ,


-- ** setResponse #method:setResponse#

#if defined(ENABLE_OVERLOADING)
    ServerMessageSetResponseMethodInfo      ,
#endif
    serverMessageSetResponse                ,


-- ** setStatus #method:setStatus#

#if defined(ENABLE_OVERLOADING)
    ServerMessageSetStatusMethodInfo        ,
#endif
    serverMessageSetStatus                  ,


-- ** stealConnection #method:stealConnection#

#if defined(ENABLE_OVERLOADING)
    ServerMessageStealConnectionMethodInfo  ,
#endif
    serverMessageStealConnection            ,


-- ** unpause #method:unpause#

#if defined(ENABLE_OVERLOADING)
    ServerMessageUnpauseMethodInfo          ,
#endif
    serverMessageUnpause                    ,




 -- * Properties


-- ** tlsPeerCertificate #attr:tlsPeerCertificate#
-- | The peer\'s t'GI.Gio.Objects.TlsCertificate.TlsCertificate' associated with the message
-- 
-- /Since: 3.2/

#if defined(ENABLE_OVERLOADING)
    ServerMessageTlsPeerCertificatePropertyInfo,
#endif
    getServerMessageTlsPeerCertificate      ,
#if defined(ENABLE_OVERLOADING)
    serverMessageTlsPeerCertificate         ,
#endif


-- ** tlsPeerCertificateErrors #attr:tlsPeerCertificateErrors#
-- | The verification errors on [ServerMessage:tlsPeerCertificate]("GI.Soup.Objects.ServerMessage#g:attr:tlsPeerCertificate")
-- 
-- /Since: 3.2/

#if defined(ENABLE_OVERLOADING)
    ServerMessageTlsPeerCertificateErrorsPropertyInfo,
#endif
    getServerMessageTlsPeerCertificateErrors,
#if defined(ENABLE_OVERLOADING)
    serverMessageTlsPeerCertificateErrors   ,
#endif




 -- * Signals


-- ** acceptCertificate #signal:acceptCertificate#

    ServerMessageAcceptCertificateCallback  ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageAcceptCertificateSignalInfo,
#endif
    afterServerMessageAcceptCertificate     ,
    onServerMessageAcceptCertificate        ,


-- ** connected #signal:connected#

    ServerMessageConnectedCallback          ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageConnectedSignalInfo        ,
#endif
    afterServerMessageConnected             ,
    onServerMessageConnected                ,


-- ** disconnected #signal:disconnected#

    ServerMessageDisconnectedCallback       ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageDisconnectedSignalInfo     ,
#endif
    afterServerMessageDisconnected          ,
    onServerMessageDisconnected             ,


-- ** finished #signal:finished#

    ServerMessageFinishedCallback           ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageFinishedSignalInfo         ,
#endif
    afterServerMessageFinished              ,
    onServerMessageFinished                 ,


-- ** gotBody #signal:gotBody#

    ServerMessageGotBodyCallback            ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageGotBodySignalInfo          ,
#endif
    afterServerMessageGotBody               ,
    onServerMessageGotBody                  ,


-- ** gotChunk #signal:gotChunk#

    ServerMessageGotChunkCallback           ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageGotChunkSignalInfo         ,
#endif
    afterServerMessageGotChunk              ,
    onServerMessageGotChunk                 ,


-- ** gotHeaders #signal:gotHeaders#

    ServerMessageGotHeadersCallback         ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageGotHeadersSignalInfo       ,
#endif
    afterServerMessageGotHeaders            ,
    onServerMessageGotHeaders               ,


-- ** wroteBody #signal:wroteBody#

    ServerMessageWroteBodyCallback          ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageWroteBodySignalInfo        ,
#endif
    afterServerMessageWroteBody             ,
    onServerMessageWroteBody                ,


-- ** wroteBodyData #signal:wroteBodyData#

    ServerMessageWroteBodyDataCallback      ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageWroteBodyDataSignalInfo    ,
#endif
    afterServerMessageWroteBodyData         ,
    onServerMessageWroteBodyData            ,


-- ** wroteChunk #signal:wroteChunk#

    ServerMessageWroteChunkCallback         ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageWroteChunkSignalInfo       ,
#endif
    afterServerMessageWroteChunk            ,
    onServerMessageWroteChunk               ,


-- ** wroteHeaders #signal:wroteHeaders#

    ServerMessageWroteHeadersCallback       ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageWroteHeadersSignalInfo     ,
#endif
    afterServerMessageWroteHeaders          ,
    onServerMessageWroteHeaders             ,


-- ** wroteInformational #signal:wroteInformational#

    ServerMessageWroteInformationalCallback ,
#if defined(ENABLE_OVERLOADING)
    ServerMessageWroteInformationalSignalInfo,
#endif
    afterServerMessageWroteInformational    ,
    onServerMessageWroteInformational       ,




    ) where

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

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

import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.Uri as GLib.Uri
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Flags as Gio.Flags
import qualified GI.Gio.Objects.IOStream as Gio.IOStream
import qualified GI.Gio.Objects.Socket as Gio.Socket
import qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress
import qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageBody as Soup.MessageBody
import {-# SOURCE #-} qualified GI.Soup.Structs.MessageHeaders as Soup.MessageHeaders

-- | Memory-managed wrapper type.
newtype ServerMessage = ServerMessage (SP.ManagedPtr ServerMessage)
    deriving (ServerMessage -> ServerMessage -> Bool
(ServerMessage -> ServerMessage -> Bool)
-> (ServerMessage -> ServerMessage -> Bool) -> Eq ServerMessage
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ServerMessage -> ServerMessage -> Bool
== :: ServerMessage -> ServerMessage -> Bool
$c/= :: ServerMessage -> ServerMessage -> Bool
/= :: ServerMessage -> ServerMessage -> Bool
Eq)

instance SP.ManagedPtrNewtype ServerMessage where
    toManagedPtr :: ServerMessage -> ManagedPtr ServerMessage
toManagedPtr (ServerMessage ManagedPtr ServerMessage
p) = ManagedPtr ServerMessage
p

foreign import ccall "soup_server_message_get_type"
    c_soup_server_message_get_type :: IO B.Types.GType

instance B.Types.TypedObject ServerMessage where
    glibType :: IO GType
glibType = IO GType
c_soup_server_message_get_type

instance B.Types.GObject ServerMessage

-- | Type class for types which can be safely cast to `ServerMessage`, for instance with `toServerMessage`.
class (SP.GObject o, O.IsDescendantOf ServerMessage o) => IsServerMessage o
instance (SP.GObject o, O.IsDescendantOf ServerMessage o) => IsServerMessage o

instance O.HasParentTypes ServerMessage
type instance O.ParentTypes ServerMessage = '[GObject.Object.Object]

-- | Cast to `ServerMessage`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toServerMessage :: (MIO.MonadIO m, IsServerMessage o) => o -> m ServerMessage
toServerMessage :: forall (m :: * -> *) o.
(MonadIO m, IsServerMessage o) =>
o -> m ServerMessage
toServerMessage = IO ServerMessage -> m ServerMessage
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO ServerMessage -> m ServerMessage)
-> (o -> IO ServerMessage) -> o -> m ServerMessage
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr ServerMessage -> ServerMessage)
-> o -> IO ServerMessage
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr ServerMessage -> ServerMessage
ServerMessage

-- | Convert 'ServerMessage' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue (Maybe ServerMessage) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_soup_server_message_get_type
    gvalueSet_ :: Ptr GValue -> Maybe ServerMessage -> IO ()
gvalueSet_ Ptr GValue
gv Maybe ServerMessage
P.Nothing = Ptr GValue -> Ptr ServerMessage -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr ServerMessage
forall a. Ptr a
FP.nullPtr :: FP.Ptr ServerMessage)
    gvalueSet_ Ptr GValue
gv (P.Just ServerMessage
obj) = ServerMessage -> (Ptr ServerMessage -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr ServerMessage
obj (Ptr GValue -> Ptr ServerMessage -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe ServerMessage)
gvalueGet_ Ptr GValue
gv = do
        Ptr ServerMessage
ptr <- Ptr GValue -> IO (Ptr ServerMessage)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr ServerMessage)
        if Ptr ServerMessage
ptr Ptr ServerMessage -> Ptr ServerMessage -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr ServerMessage
forall a. Ptr a
FP.nullPtr
        then ServerMessage -> Maybe ServerMessage
forall a. a -> Maybe a
P.Just (ServerMessage -> Maybe ServerMessage)
-> IO ServerMessage -> IO (Maybe ServerMessage)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr ServerMessage -> ServerMessage)
-> Ptr ServerMessage -> IO ServerMessage
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr ServerMessage -> ServerMessage
ServerMessage Ptr ServerMessage
ptr
        else Maybe ServerMessage -> IO (Maybe ServerMessage)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ServerMessage
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveServerMessageMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
    ResolveServerMessageMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveServerMessageMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveServerMessageMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveServerMessageMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveServerMessageMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveServerMessageMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveServerMessageMethod "isOptionsPing" o = ServerMessageIsOptionsPingMethodInfo
    ResolveServerMessageMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveServerMessageMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveServerMessageMethod "pause" o = ServerMessagePauseMethodInfo
    ResolveServerMessageMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveServerMessageMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveServerMessageMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveServerMessageMethod "stealConnection" o = ServerMessageStealConnectionMethodInfo
    ResolveServerMessageMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveServerMessageMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveServerMessageMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveServerMessageMethod "unpause" o = ServerMessageUnpauseMethodInfo
    ResolveServerMessageMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveServerMessageMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveServerMessageMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveServerMessageMethod "getHttpVersion" o = ServerMessageGetHttpVersionMethodInfo
    ResolveServerMessageMethod "getLocalAddress" o = ServerMessageGetLocalAddressMethodInfo
    ResolveServerMessageMethod "getMethod" o = ServerMessageGetMethodMethodInfo
    ResolveServerMessageMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveServerMessageMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveServerMessageMethod "getReasonPhrase" o = ServerMessageGetReasonPhraseMethodInfo
    ResolveServerMessageMethod "getRemoteAddress" o = ServerMessageGetRemoteAddressMethodInfo
    ResolveServerMessageMethod "getRemoteHost" o = ServerMessageGetRemoteHostMethodInfo
    ResolveServerMessageMethod "getRequestBody" o = ServerMessageGetRequestBodyMethodInfo
    ResolveServerMessageMethod "getRequestHeaders" o = ServerMessageGetRequestHeadersMethodInfo
    ResolveServerMessageMethod "getResponseBody" o = ServerMessageGetResponseBodyMethodInfo
    ResolveServerMessageMethod "getResponseHeaders" o = ServerMessageGetResponseHeadersMethodInfo
    ResolveServerMessageMethod "getSocket" o = ServerMessageGetSocketMethodInfo
    ResolveServerMessageMethod "getStatus" o = ServerMessageGetStatusMethodInfo
    ResolveServerMessageMethod "getTlsPeerCertificate" o = ServerMessageGetTlsPeerCertificateMethodInfo
    ResolveServerMessageMethod "getTlsPeerCertificateErrors" o = ServerMessageGetTlsPeerCertificateErrorsMethodInfo
    ResolveServerMessageMethod "getUri" o = ServerMessageGetUriMethodInfo
    ResolveServerMessageMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveServerMessageMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveServerMessageMethod "setHttpVersion" o = ServerMessageSetHttpVersionMethodInfo
    ResolveServerMessageMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveServerMessageMethod "setRedirect" o = ServerMessageSetRedirectMethodInfo
    ResolveServerMessageMethod "setResponse" o = ServerMessageSetResponseMethodInfo
    ResolveServerMessageMethod "setStatus" o = ServerMessageSetStatusMethodInfo
    ResolveServerMessageMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveServerMessageMethod t ServerMessage, O.OverloadedMethod info ServerMessage p) => OL.IsLabel t (ServerMessage -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveServerMessageMethod t ServerMessage, O.OverloadedMethod info ServerMessage p, R.HasField t ServerMessage p) => R.HasField t ServerMessage p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveServerMessageMethod t ServerMessage, O.OverloadedMethodInfo info ServerMessage) => OL.IsLabel t (O.MethodProxy info ServerMessage) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- signal ServerMessage::accept-certificate
-- | Emitted during the /@msg@/\'s connection TLS handshake
-- after client TLS certificate has been received.
-- You can return 'P.True' to accept /@tlsCertificate@/ despite
-- /@tlsErrors@/.
type ServerMessageAcceptCertificateCallback =
    Gio.TlsCertificate.TlsCertificate
    -- ^ /@tlsPeerCertificate@/: the peer\'s t'GI.Gio.Objects.TlsCertificate.TlsCertificate'
    -> [Gio.Flags.TlsCertificateFlags]
    -- ^ /@tlsPeerErrors@/: the tls errors of /@tlsCertificate@/
    -> IO Bool
    -- ^ __Returns:__ 'P.True' to accept the TLS certificate and stop other
    --   handlers from being invoked, or 'P.False' to propagate the
    --   event further.

type C_ServerMessageAcceptCertificateCallback =
    Ptr ServerMessage ->                    -- object
    Ptr Gio.TlsCertificate.TlsCertificate ->
    CUInt ->
    Ptr () ->                               -- user_data
    IO CInt

-- | Generate a function pointer callable from C code, from a `C_ServerMessageAcceptCertificateCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageAcceptCertificateCallback :: C_ServerMessageAcceptCertificateCallback -> IO (FunPtr C_ServerMessageAcceptCertificateCallback)

wrap_ServerMessageAcceptCertificateCallback :: 
    GObject a => (a -> ServerMessageAcceptCertificateCallback) ->
    C_ServerMessageAcceptCertificateCallback
wrap_ServerMessageAcceptCertificateCallback :: forall a.
GObject a =>
(a -> ServerMessageAcceptCertificateCallback)
-> C_ServerMessageAcceptCertificateCallback
wrap_ServerMessageAcceptCertificateCallback a -> ServerMessageAcceptCertificateCallback
gi'cb Ptr ServerMessage
gi'selfPtr Ptr TlsCertificate
tlsPeerCertificate CUInt
tlsPeerErrors Ptr ()
_ = do
    TlsCertificate
tlsPeerCertificate' <- ((ManagedPtr TlsCertificate -> TlsCertificate)
-> Ptr TlsCertificate -> IO TlsCertificate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TlsCertificate -> TlsCertificate
Gio.TlsCertificate.TlsCertificate) Ptr TlsCertificate
tlsPeerCertificate
    let tlsPeerErrors' :: [TlsCertificateFlags]
tlsPeerErrors' = CUInt -> [TlsCertificateFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
tlsPeerErrors
    Bool
result <- Ptr ServerMessage -> (ServerMessage -> IO Bool) -> IO Bool
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO Bool) -> IO Bool)
-> (ServerMessage -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> ServerMessageAcceptCertificateCallback
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self)  TlsCertificate
tlsPeerCertificate' [TlsCertificateFlags]
tlsPeerErrors'
    let result' :: CInt
result' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
result
    CInt -> IO CInt
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CInt
result'


-- | Connect a signal handler for the [acceptCertificate](#signal:acceptCertificate) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #acceptCertificate callback
-- @
-- 
-- 
onServerMessageAcceptCertificate :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageAcceptCertificateCallback) -> m SignalHandlerId
onServerMessageAcceptCertificate :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a
-> ((?self::a) => ServerMessageAcceptCertificateCallback)
-> m SignalHandlerId
onServerMessageAcceptCertificate a
obj (?self::a) => ServerMessageAcceptCertificateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ServerMessageAcceptCertificateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ServerMessageAcceptCertificateCallback
ServerMessageAcceptCertificateCallback
cb
    let wrapped' :: C_ServerMessageAcceptCertificateCallback
wrapped' = (a -> ServerMessageAcceptCertificateCallback)
-> C_ServerMessageAcceptCertificateCallback
forall a.
GObject a =>
(a -> ServerMessageAcceptCertificateCallback)
-> C_ServerMessageAcceptCertificateCallback
wrap_ServerMessageAcceptCertificateCallback a -> ServerMessageAcceptCertificateCallback
wrapped
    FunPtr C_ServerMessageAcceptCertificateCallback
wrapped'' <- C_ServerMessageAcceptCertificateCallback
-> IO (FunPtr C_ServerMessageAcceptCertificateCallback)
mk_ServerMessageAcceptCertificateCallback C_ServerMessageAcceptCertificateCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageAcceptCertificateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"accept-certificate" FunPtr C_ServerMessageAcceptCertificateCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [acceptCertificate](#signal:acceptCertificate) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #acceptCertificate callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageAcceptCertificate :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageAcceptCertificateCallback) -> m SignalHandlerId
afterServerMessageAcceptCertificate :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a
-> ((?self::a) => ServerMessageAcceptCertificateCallback)
-> m SignalHandlerId
afterServerMessageAcceptCertificate a
obj (?self::a) => ServerMessageAcceptCertificateCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ServerMessageAcceptCertificateCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ServerMessageAcceptCertificateCallback
ServerMessageAcceptCertificateCallback
cb
    let wrapped' :: C_ServerMessageAcceptCertificateCallback
wrapped' = (a -> ServerMessageAcceptCertificateCallback)
-> C_ServerMessageAcceptCertificateCallback
forall a.
GObject a =>
(a -> ServerMessageAcceptCertificateCallback)
-> C_ServerMessageAcceptCertificateCallback
wrap_ServerMessageAcceptCertificateCallback a -> ServerMessageAcceptCertificateCallback
wrapped
    FunPtr C_ServerMessageAcceptCertificateCallback
wrapped'' <- C_ServerMessageAcceptCertificateCallback
-> IO (FunPtr C_ServerMessageAcceptCertificateCallback)
mk_ServerMessageAcceptCertificateCallback C_ServerMessageAcceptCertificateCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageAcceptCertificateCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"accept-certificate" FunPtr C_ServerMessageAcceptCertificateCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageAcceptCertificateSignalInfo
instance SignalInfo ServerMessageAcceptCertificateSignalInfo where
    type HaskellCallbackType ServerMessageAcceptCertificateSignalInfo = ServerMessageAcceptCertificateCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageAcceptCertificateCallback cb
        cb'' <- mk_ServerMessageAcceptCertificateCallback cb'
        connectSignalFunPtr obj "accept-certificate" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::accept-certificate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:acceptCertificate"})

#endif

-- signal ServerMessage::connected
-- | Emitted when the /@msg@/\'s socket is connected and the TLS handshake completed.
type ServerMessageConnectedCallback =
    IO ()

type C_ServerMessageConnectedCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageConnectedCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageConnectedCallback :: C_ServerMessageConnectedCallback -> IO (FunPtr C_ServerMessageConnectedCallback)

wrap_ServerMessageConnectedCallback :: 
    GObject a => (a -> ServerMessageConnectedCallback) ->
    C_ServerMessageConnectedCallback
wrap_ServerMessageConnectedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageConnectedCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [connected](#signal:connected) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #connected callback
-- @
-- 
-- 
onServerMessageConnected :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageConnectedCallback) -> m SignalHandlerId
onServerMessageConnected :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageConnected a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageConnectedCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageConnectedCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"connected" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [connected](#signal:connected) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #connected callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageConnected :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageConnectedCallback) -> m SignalHandlerId
afterServerMessageConnected :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageConnected a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageConnectedCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageConnectedCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"connected" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageConnectedSignalInfo
instance SignalInfo ServerMessageConnectedSignalInfo where
    type HaskellCallbackType ServerMessageConnectedSignalInfo = ServerMessageConnectedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageConnectedCallback cb
        cb'' <- mk_ServerMessageConnectedCallback cb'
        connectSignalFunPtr obj "connected" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::connected"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:connected"})

#endif

-- signal ServerMessage::disconnected
-- | Emitted when the /@msg@/\'s socket is disconnected.
type ServerMessageDisconnectedCallback =
    IO ()

type C_ServerMessageDisconnectedCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageDisconnectedCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageDisconnectedCallback :: C_ServerMessageDisconnectedCallback -> IO (FunPtr C_ServerMessageDisconnectedCallback)

wrap_ServerMessageDisconnectedCallback :: 
    GObject a => (a -> ServerMessageDisconnectedCallback) ->
    C_ServerMessageDisconnectedCallback
wrap_ServerMessageDisconnectedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageDisconnectedCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [disconnected](#signal:disconnected) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #disconnected callback
-- @
-- 
-- 
onServerMessageDisconnected :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageDisconnectedCallback) -> m SignalHandlerId
onServerMessageDisconnected :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageDisconnected a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageDisconnectedCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageDisconnectedCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"disconnected" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [disconnected](#signal:disconnected) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #disconnected callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageDisconnected :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageDisconnectedCallback) -> m SignalHandlerId
afterServerMessageDisconnected :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageDisconnected a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageDisconnectedCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageDisconnectedCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"disconnected" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageDisconnectedSignalInfo
instance SignalInfo ServerMessageDisconnectedSignalInfo where
    type HaskellCallbackType ServerMessageDisconnectedSignalInfo = ServerMessageDisconnectedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageDisconnectedCallback cb
        cb'' <- mk_ServerMessageDisconnectedCallback cb'
        connectSignalFunPtr obj "disconnected" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::disconnected"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:disconnected"})

#endif

-- signal ServerMessage::finished
-- | Emitted when all HTTP processing is finished for a message.
-- (After [signal/@serverMessage@/[wroteBody](#g:signal:wroteBody)]).
type ServerMessageFinishedCallback =
    IO ()

type C_ServerMessageFinishedCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageFinishedCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageFinishedCallback :: C_ServerMessageFinishedCallback -> IO (FunPtr C_ServerMessageFinishedCallback)

wrap_ServerMessageFinishedCallback :: 
    GObject a => (a -> ServerMessageFinishedCallback) ->
    C_ServerMessageFinishedCallback
wrap_ServerMessageFinishedCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageFinishedCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [finished](#signal:finished) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #finished callback
-- @
-- 
-- 
onServerMessageFinished :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageFinishedCallback) -> m SignalHandlerId
onServerMessageFinished :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageFinished a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageFinishedCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageFinishedCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"finished" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [finished](#signal:finished) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #finished callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageFinished :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageFinishedCallback) -> m SignalHandlerId
afterServerMessageFinished :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageFinished a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageFinishedCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageFinishedCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"finished" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageFinishedSignalInfo
instance SignalInfo ServerMessageFinishedSignalInfo where
    type HaskellCallbackType ServerMessageFinishedSignalInfo = ServerMessageFinishedCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageFinishedCallback cb
        cb'' <- mk_ServerMessageFinishedCallback cb'
        connectSignalFunPtr obj "finished" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::finished"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:finished"})

#endif

-- signal ServerMessage::got-body
-- | Emitted after receiving the complete request body.
type ServerMessageGotBodyCallback =
    IO ()

type C_ServerMessageGotBodyCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageGotBodyCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageGotBodyCallback :: C_ServerMessageGotBodyCallback -> IO (FunPtr C_ServerMessageGotBodyCallback)

wrap_ServerMessageGotBodyCallback :: 
    GObject a => (a -> ServerMessageGotBodyCallback) ->
    C_ServerMessageGotBodyCallback
wrap_ServerMessageGotBodyCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageGotBodyCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [gotBody](#signal:gotBody) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #gotBody callback
-- @
-- 
-- 
onServerMessageGotBody :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageGotBodyCallback) -> m SignalHandlerId
onServerMessageGotBody :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageGotBody a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageGotBodyCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageGotBodyCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-body" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [gotBody](#signal:gotBody) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #gotBody callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageGotBody :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageGotBodyCallback) -> m SignalHandlerId
afterServerMessageGotBody :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageGotBody a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageGotBodyCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageGotBodyCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-body" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageGotBodySignalInfo
instance SignalInfo ServerMessageGotBodySignalInfo where
    type HaskellCallbackType ServerMessageGotBodySignalInfo = ServerMessageGotBodyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageGotBodyCallback cb
        cb'' <- mk_ServerMessageGotBodyCallback cb'
        connectSignalFunPtr obj "got-body" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::got-body"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:gotBody"})

#endif

-- signal ServerMessage::got-chunk
-- | Emitted after receiving a chunk of a message body.
-- 
-- Note that \"chunk\" in this context means any subpiece of the body, not
-- necessarily the specific HTTP 1.1 chunks sent by the other side.
type ServerMessageGotChunkCallback =
    GLib.Bytes.Bytes
    -- ^ /@chunk@/: the just-read chunk
    -> IO ()

type C_ServerMessageGotChunkCallback =
    Ptr ServerMessage ->                    -- object
    Ptr GLib.Bytes.Bytes ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageGotChunkCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageGotChunkCallback :: C_ServerMessageGotChunkCallback -> IO (FunPtr C_ServerMessageGotChunkCallback)

wrap_ServerMessageGotChunkCallback :: 
    GObject a => (a -> ServerMessageGotChunkCallback) ->
    C_ServerMessageGotChunkCallback
wrap_ServerMessageGotChunkCallback :: forall a.
GObject a =>
(a -> ServerMessageGotChunkCallback)
-> C_ServerMessageGotChunkCallback
wrap_ServerMessageGotChunkCallback a -> ServerMessageGotChunkCallback
gi'cb Ptr ServerMessage
gi'selfPtr Ptr Bytes
chunk Ptr ()
_ = do
    Ptr Bytes -> ServerMessageGotChunkCallback -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient  Ptr Bytes
chunk (ServerMessageGotChunkCallback -> IO ())
-> ServerMessageGotChunkCallback -> IO ()
forall a b. (a -> b) -> a -> b
$ \Bytes
chunk' -> do
        Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> ServerMessageGotChunkCallback
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self)  Bytes
chunk'


-- | Connect a signal handler for the [gotChunk](#signal:gotChunk) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #gotChunk callback
-- @
-- 
-- 
onServerMessageGotChunk :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageGotChunkCallback) -> m SignalHandlerId
onServerMessageGotChunk :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a
-> ((?self::a) => ServerMessageGotChunkCallback)
-> m SignalHandlerId
onServerMessageGotChunk a
obj (?self::a) => ServerMessageGotChunkCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ServerMessageGotChunkCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ServerMessageGotChunkCallback
ServerMessageGotChunkCallback
cb
    let wrapped' :: C_ServerMessageGotChunkCallback
wrapped' = (a -> ServerMessageGotChunkCallback)
-> C_ServerMessageGotChunkCallback
forall a.
GObject a =>
(a -> ServerMessageGotChunkCallback)
-> C_ServerMessageGotChunkCallback
wrap_ServerMessageGotChunkCallback a -> ServerMessageGotChunkCallback
wrapped
    FunPtr C_ServerMessageGotChunkCallback
wrapped'' <- C_ServerMessageGotChunkCallback
-> IO (FunPtr C_ServerMessageGotChunkCallback)
mk_ServerMessageGotChunkCallback C_ServerMessageGotChunkCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageGotChunkCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-chunk" FunPtr C_ServerMessageGotChunkCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [gotChunk](#signal:gotChunk) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #gotChunk callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageGotChunk :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageGotChunkCallback) -> m SignalHandlerId
afterServerMessageGotChunk :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a
-> ((?self::a) => ServerMessageGotChunkCallback)
-> m SignalHandlerId
afterServerMessageGotChunk a
obj (?self::a) => ServerMessageGotChunkCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ServerMessageGotChunkCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ServerMessageGotChunkCallback
ServerMessageGotChunkCallback
cb
    let wrapped' :: C_ServerMessageGotChunkCallback
wrapped' = (a -> ServerMessageGotChunkCallback)
-> C_ServerMessageGotChunkCallback
forall a.
GObject a =>
(a -> ServerMessageGotChunkCallback)
-> C_ServerMessageGotChunkCallback
wrap_ServerMessageGotChunkCallback a -> ServerMessageGotChunkCallback
wrapped
    FunPtr C_ServerMessageGotChunkCallback
wrapped'' <- C_ServerMessageGotChunkCallback
-> IO (FunPtr C_ServerMessageGotChunkCallback)
mk_ServerMessageGotChunkCallback C_ServerMessageGotChunkCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageGotChunkCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-chunk" FunPtr C_ServerMessageGotChunkCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageGotChunkSignalInfo
instance SignalInfo ServerMessageGotChunkSignalInfo where
    type HaskellCallbackType ServerMessageGotChunkSignalInfo = ServerMessageGotChunkCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageGotChunkCallback cb
        cb'' <- mk_ServerMessageGotChunkCallback cb'
        connectSignalFunPtr obj "got-chunk" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::got-chunk"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:gotChunk"})

#endif

-- signal ServerMessage::got-headers
-- | Emitted after receiving the Request-Line and request headers.
type ServerMessageGotHeadersCallback =
    IO ()

type C_ServerMessageGotHeadersCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageGotHeadersCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageGotHeadersCallback :: C_ServerMessageGotHeadersCallback -> IO (FunPtr C_ServerMessageGotHeadersCallback)

wrap_ServerMessageGotHeadersCallback :: 
    GObject a => (a -> ServerMessageGotHeadersCallback) ->
    C_ServerMessageGotHeadersCallback
wrap_ServerMessageGotHeadersCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageGotHeadersCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [gotHeaders](#signal:gotHeaders) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #gotHeaders callback
-- @
-- 
-- 
onServerMessageGotHeaders :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageGotHeadersCallback) -> m SignalHandlerId
onServerMessageGotHeaders :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageGotHeaders a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageGotHeadersCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageGotHeadersCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-headers" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [gotHeaders](#signal:gotHeaders) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #gotHeaders callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageGotHeaders :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageGotHeadersCallback) -> m SignalHandlerId
afterServerMessageGotHeaders :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageGotHeaders a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageGotHeadersCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageGotHeadersCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"got-headers" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageGotHeadersSignalInfo
instance SignalInfo ServerMessageGotHeadersSignalInfo where
    type HaskellCallbackType ServerMessageGotHeadersSignalInfo = ServerMessageGotHeadersCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageGotHeadersCallback cb
        cb'' <- mk_ServerMessageGotHeadersCallback cb'
        connectSignalFunPtr obj "got-headers" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::got-headers"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:gotHeaders"})

#endif

-- signal ServerMessage::wrote-body
-- | Emitted immediately after writing the complete response body for a
-- message.
type ServerMessageWroteBodyCallback =
    IO ()

type C_ServerMessageWroteBodyCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageWroteBodyCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageWroteBodyCallback :: C_ServerMessageWroteBodyCallback -> IO (FunPtr C_ServerMessageWroteBodyCallback)

wrap_ServerMessageWroteBodyCallback :: 
    GObject a => (a -> ServerMessageWroteBodyCallback) ->
    C_ServerMessageWroteBodyCallback
wrap_ServerMessageWroteBodyCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteBodyCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [wroteBody](#signal:wroteBody) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #wroteBody callback
-- @
-- 
-- 
onServerMessageWroteBody :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteBodyCallback) -> m SignalHandlerId
onServerMessageWroteBody :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageWroteBody a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteBodyCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageWroteBodyCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-body" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [wroteBody](#signal:wroteBody) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #wroteBody callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageWroteBody :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteBodyCallback) -> m SignalHandlerId
afterServerMessageWroteBody :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageWroteBody a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteBodyCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageWroteBodyCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-body" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageWroteBodySignalInfo
instance SignalInfo ServerMessageWroteBodySignalInfo where
    type HaskellCallbackType ServerMessageWroteBodySignalInfo = ServerMessageWroteBodyCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageWroteBodyCallback cb
        cb'' <- mk_ServerMessageWroteBodyCallback cb'
        connectSignalFunPtr obj "wrote-body" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::wrote-body"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:wroteBody"})

#endif

-- signal ServerMessage::wrote-body-data
-- | Emitted immediately after writing a portion of the message
-- body to the network.
type ServerMessageWroteBodyDataCallback =
    Word32
    -- ^ /@chunkSize@/: the number of bytes written
    -> IO ()

type C_ServerMessageWroteBodyDataCallback =
    Ptr ServerMessage ->                    -- object
    Word32 ->
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageWroteBodyDataCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageWroteBodyDataCallback :: C_ServerMessageWroteBodyDataCallback -> IO (FunPtr C_ServerMessageWroteBodyDataCallback)

wrap_ServerMessageWroteBodyDataCallback :: 
    GObject a => (a -> ServerMessageWroteBodyDataCallback) ->
    C_ServerMessageWroteBodyDataCallback
wrap_ServerMessageWroteBodyDataCallback :: forall a.
GObject a =>
(a -> ServerMessageWroteBodyDataCallback)
-> C_ServerMessageWroteBodyDataCallback
wrap_ServerMessageWroteBodyDataCallback a -> ServerMessageWroteBodyDataCallback
gi'cb Ptr ServerMessage
gi'selfPtr Word32
chunkSize Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> ServerMessageWroteBodyDataCallback
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self)  Word32
chunkSize


-- | Connect a signal handler for the [wroteBodyData](#signal:wroteBodyData) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #wroteBodyData callback
-- @
-- 
-- 
onServerMessageWroteBodyData :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteBodyDataCallback) -> m SignalHandlerId
onServerMessageWroteBodyData :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a
-> ((?self::a) => ServerMessageWroteBodyDataCallback)
-> m SignalHandlerId
onServerMessageWroteBodyData a
obj (?self::a) => ServerMessageWroteBodyDataCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ServerMessageWroteBodyDataCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ServerMessageWroteBodyDataCallback
ServerMessageWroteBodyDataCallback
cb
    let wrapped' :: C_ServerMessageWroteBodyDataCallback
wrapped' = (a -> ServerMessageWroteBodyDataCallback)
-> C_ServerMessageWroteBodyDataCallback
forall a.
GObject a =>
(a -> ServerMessageWroteBodyDataCallback)
-> C_ServerMessageWroteBodyDataCallback
wrap_ServerMessageWroteBodyDataCallback a -> ServerMessageWroteBodyDataCallback
wrapped
    FunPtr C_ServerMessageWroteBodyDataCallback
wrapped'' <- C_ServerMessageWroteBodyDataCallback
-> IO (FunPtr C_ServerMessageWroteBodyDataCallback)
mk_ServerMessageWroteBodyDataCallback C_ServerMessageWroteBodyDataCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageWroteBodyDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-body-data" FunPtr C_ServerMessageWroteBodyDataCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [wroteBodyData](#signal:wroteBodyData) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #wroteBodyData callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageWroteBodyData :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteBodyDataCallback) -> m SignalHandlerId
afterServerMessageWroteBodyData :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a
-> ((?self::a) => ServerMessageWroteBodyDataCallback)
-> m SignalHandlerId
afterServerMessageWroteBodyData a
obj (?self::a) => ServerMessageWroteBodyDataCallback
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> ServerMessageWroteBodyDataCallback
wrapped a
self = let ?self = a
?self::a
self in (?self::a) => ServerMessageWroteBodyDataCallback
ServerMessageWroteBodyDataCallback
cb
    let wrapped' :: C_ServerMessageWroteBodyDataCallback
wrapped' = (a -> ServerMessageWroteBodyDataCallback)
-> C_ServerMessageWroteBodyDataCallback
forall a.
GObject a =>
(a -> ServerMessageWroteBodyDataCallback)
-> C_ServerMessageWroteBodyDataCallback
wrap_ServerMessageWroteBodyDataCallback a -> ServerMessageWroteBodyDataCallback
wrapped
    FunPtr C_ServerMessageWroteBodyDataCallback
wrapped'' <- C_ServerMessageWroteBodyDataCallback
-> IO (FunPtr C_ServerMessageWroteBodyDataCallback)
mk_ServerMessageWroteBodyDataCallback C_ServerMessageWroteBodyDataCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageWroteBodyDataCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-body-data" FunPtr C_ServerMessageWroteBodyDataCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageWroteBodyDataSignalInfo
instance SignalInfo ServerMessageWroteBodyDataSignalInfo where
    type HaskellCallbackType ServerMessageWroteBodyDataSignalInfo = ServerMessageWroteBodyDataCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageWroteBodyDataCallback cb
        cb'' <- mk_ServerMessageWroteBodyDataCallback cb'
        connectSignalFunPtr obj "wrote-body-data" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::wrote-body-data"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:wroteBodyData"})

#endif

-- signal ServerMessage::wrote-chunk
-- | Emitted immediately after writing a body chunk for a message.
-- 
-- Note that this signal is not parallel to
-- [signal/@serverMessage@/[gotChunk](#g:signal:gotChunk)]; it is emitted only when a complete
-- chunk (added with [method/@messageBody@/.append] or
-- [method/@messageBody@/.append_bytes] has been written. To get
-- more useful continuous progress information, use
-- [signal/@serverMessage@/[wroteBodyData](#g:signal:wroteBodyData)].
type ServerMessageWroteChunkCallback =
    IO ()

type C_ServerMessageWroteChunkCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageWroteChunkCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageWroteChunkCallback :: C_ServerMessageWroteChunkCallback -> IO (FunPtr C_ServerMessageWroteChunkCallback)

wrap_ServerMessageWroteChunkCallback :: 
    GObject a => (a -> ServerMessageWroteChunkCallback) ->
    C_ServerMessageWroteChunkCallback
wrap_ServerMessageWroteChunkCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteChunkCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [wroteChunk](#signal:wroteChunk) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #wroteChunk callback
-- @
-- 
-- 
onServerMessageWroteChunk :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteChunkCallback) -> m SignalHandlerId
onServerMessageWroteChunk :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageWroteChunk a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteChunkCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageWroteChunkCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-chunk" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [wroteChunk](#signal:wroteChunk) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #wroteChunk callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageWroteChunk :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteChunkCallback) -> m SignalHandlerId
afterServerMessageWroteChunk :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageWroteChunk a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteChunkCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageWroteChunkCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-chunk" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageWroteChunkSignalInfo
instance SignalInfo ServerMessageWroteChunkSignalInfo where
    type HaskellCallbackType ServerMessageWroteChunkSignalInfo = ServerMessageWroteChunkCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageWroteChunkCallback cb
        cb'' <- mk_ServerMessageWroteChunkCallback cb'
        connectSignalFunPtr obj "wrote-chunk" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::wrote-chunk"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:wroteChunk"})

#endif

-- signal ServerMessage::wrote-headers
-- | Emitted immediately after writing the response headers for a
-- message.
type ServerMessageWroteHeadersCallback =
    IO ()

type C_ServerMessageWroteHeadersCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageWroteHeadersCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageWroteHeadersCallback :: C_ServerMessageWroteHeadersCallback -> IO (FunPtr C_ServerMessageWroteHeadersCallback)

wrap_ServerMessageWroteHeadersCallback :: 
    GObject a => (a -> ServerMessageWroteHeadersCallback) ->
    C_ServerMessageWroteHeadersCallback
wrap_ServerMessageWroteHeadersCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteHeadersCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [wroteHeaders](#signal:wroteHeaders) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #wroteHeaders callback
-- @
-- 
-- 
onServerMessageWroteHeaders :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteHeadersCallback) -> m SignalHandlerId
onServerMessageWroteHeaders :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageWroteHeaders a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteHeadersCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageWroteHeadersCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-headers" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [wroteHeaders](#signal:wroteHeaders) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #wroteHeaders callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageWroteHeaders :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteHeadersCallback) -> m SignalHandlerId
afterServerMessageWroteHeaders :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageWroteHeaders a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteHeadersCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageWroteHeadersCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-headers" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageWroteHeadersSignalInfo
instance SignalInfo ServerMessageWroteHeadersSignalInfo where
    type HaskellCallbackType ServerMessageWroteHeadersSignalInfo = ServerMessageWroteHeadersCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageWroteHeadersCallback cb
        cb'' <- mk_ServerMessageWroteHeadersCallback cb'
        connectSignalFunPtr obj "wrote-headers" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::wrote-headers"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:wroteHeaders"})

#endif

-- signal ServerMessage::wrote-informational
-- | Emitted immediately after writing a 1xx (Informational) response.
type ServerMessageWroteInformationalCallback =
    IO ()

type C_ServerMessageWroteInformationalCallback =
    Ptr ServerMessage ->                    -- object
    Ptr () ->                               -- user_data
    IO ()

-- | Generate a function pointer callable from C code, from a `C_ServerMessageWroteInformationalCallback`.
foreign import ccall "wrapper"
    mk_ServerMessageWroteInformationalCallback :: C_ServerMessageWroteInformationalCallback -> IO (FunPtr C_ServerMessageWroteInformationalCallback)

wrap_ServerMessageWroteInformationalCallback :: 
    GObject a => (a -> ServerMessageWroteInformationalCallback) ->
    C_ServerMessageWroteInformationalCallback
wrap_ServerMessageWroteInformationalCallback :: forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteInformationalCallback a -> IO ()
gi'cb Ptr ServerMessage
gi'selfPtr Ptr ()
_ = do
    Ptr ServerMessage -> (ServerMessage -> IO ()) -> IO ()
forall a b.
(HasCallStack, ManagedPtrNewtype a) =>
Ptr a -> (a -> IO b) -> IO b
B.ManagedPtr.withTransient Ptr ServerMessage
gi'selfPtr ((ServerMessage -> IO ()) -> IO ())
-> (ServerMessage -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ServerMessage
gi'self -> a -> IO ()
gi'cb (ServerMessage -> a
forall a b. Coercible a b => a -> b
Coerce.coerce ServerMessage
gi'self) 


-- | Connect a signal handler for the [wroteInformational](#signal:wroteInformational) signal, to be run before the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.on' serverMessage #wroteInformational callback
-- @
-- 
-- 
onServerMessageWroteInformational :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteInformationalCallback) -> m SignalHandlerId
onServerMessageWroteInformational :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
onServerMessageWroteInformational a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteInformationalCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageWroteInformationalCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-informational" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectBefore Maybe Text
forall a. Maybe a
Nothing

-- | Connect a signal handler for the [wroteInformational](#signal:wroteInformational) signal, to be run after the default handler.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Signals.after' serverMessage #wroteInformational callback
-- @
-- 
-- 
-- 
-- By default the object invoking the signal is not passed to the callback.
-- If you need to access it, you can use the implit @?self@ parameter.
-- Note that this requires activating the @ImplicitParams@ GHC extension.
-- 
afterServerMessageWroteInformational :: (IsServerMessage a, MonadIO m) => a -> ((?self :: a) => ServerMessageWroteInformationalCallback) -> m SignalHandlerId
afterServerMessageWroteInformational :: forall a (m :: * -> *).
(IsServerMessage a, MonadIO m) =>
a -> ((?self::a) => IO ()) -> m SignalHandlerId
afterServerMessageWroteInformational a
obj (?self::a) => IO ()
cb = IO SignalHandlerId -> m SignalHandlerId
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SignalHandlerId -> m SignalHandlerId)
-> IO SignalHandlerId -> m SignalHandlerId
forall a b. (a -> b) -> a -> b
$ do
    let wrapped :: a -> IO ()
wrapped a
self = let ?self = a
?self::a
self in IO ()
(?self::a) => IO ()
cb
    let wrapped' :: C_ServerMessageConnectedCallback
wrapped' = (a -> IO ()) -> C_ServerMessageConnectedCallback
forall a.
GObject a =>
(a -> IO ()) -> C_ServerMessageConnectedCallback
wrap_ServerMessageWroteInformationalCallback a -> IO ()
wrapped
    FunPtr C_ServerMessageConnectedCallback
wrapped'' <- C_ServerMessageConnectedCallback
-> IO (FunPtr C_ServerMessageConnectedCallback)
mk_ServerMessageWroteInformationalCallback C_ServerMessageConnectedCallback
wrapped'
    a
-> Text
-> FunPtr C_ServerMessageConnectedCallback
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
forall o a.
GObject o =>
o
-> Text
-> FunPtr a
-> SignalConnectMode
-> Maybe Text
-> IO SignalHandlerId
connectSignalFunPtr a
obj Text
"wrote-informational" FunPtr C_ServerMessageConnectedCallback
wrapped'' SignalConnectMode
SignalConnectAfter Maybe Text
forall a. Maybe a
Nothing


#if defined(ENABLE_OVERLOADING)
data ServerMessageWroteInformationalSignalInfo
instance SignalInfo ServerMessageWroteInformationalSignalInfo where
    type HaskellCallbackType ServerMessageWroteInformationalSignalInfo = ServerMessageWroteInformationalCallback
    connectSignal obj cb connectMode detail = do
        let cb' = wrap_ServerMessageWroteInformationalCallback cb
        cb'' <- mk_ServerMessageWroteInformationalCallback cb'
        connectSignalFunPtr obj "wrote-informational" cb'' connectMode detail
    dbgSignalInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage::wrote-informational"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:signal:wroteInformational"})

#endif

-- VVV Prop "tls-peer-certificate"
   -- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just True,Nothing)

-- | Get the value of the “@tls-peer-certificate@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' serverMessage #tlsPeerCertificate
-- @
getServerMessageTlsPeerCertificate :: (MonadIO m, IsServerMessage o) => o -> m (Maybe Gio.TlsCertificate.TlsCertificate)
getServerMessageTlsPeerCertificate :: forall (m :: * -> *) o.
(MonadIO m, IsServerMessage o) =>
o -> m (Maybe TlsCertificate)
getServerMessageTlsPeerCertificate o
obj = IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate))
-> IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate)
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr TlsCertificate -> TlsCertificate)
-> IO (Maybe TlsCertificate)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj String
"tls-peer-certificate" ManagedPtr TlsCertificate -> TlsCertificate
Gio.TlsCertificate.TlsCertificate

#if defined(ENABLE_OVERLOADING)
data ServerMessageTlsPeerCertificatePropertyInfo
instance AttrInfo ServerMessageTlsPeerCertificatePropertyInfo where
    type AttrAllowedOps ServerMessageTlsPeerCertificatePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint ServerMessageTlsPeerCertificatePropertyInfo = IsServerMessage
    type AttrSetTypeConstraint ServerMessageTlsPeerCertificatePropertyInfo = (~) ()
    type AttrTransferTypeConstraint ServerMessageTlsPeerCertificatePropertyInfo = (~) ()
    type AttrTransferType ServerMessageTlsPeerCertificatePropertyInfo = ()
    type AttrGetType ServerMessageTlsPeerCertificatePropertyInfo = (Maybe Gio.TlsCertificate.TlsCertificate)
    type AttrLabel ServerMessageTlsPeerCertificatePropertyInfo = "tls-peer-certificate"
    type AttrOrigin ServerMessageTlsPeerCertificatePropertyInfo = ServerMessage
    attrGet = getServerMessageTlsPeerCertificate
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.tlsPeerCertificate"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:attr:tlsPeerCertificate"
        })
#endif

-- VVV Prop "tls-peer-certificate-errors"
   -- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"})
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@tls-peer-certificate-errors@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' serverMessage #tlsPeerCertificateErrors
-- @
getServerMessageTlsPeerCertificateErrors :: (MonadIO m, IsServerMessage o) => o -> m [Gio.Flags.TlsCertificateFlags]
getServerMessageTlsPeerCertificateErrors :: forall (m :: * -> *) o.
(MonadIO m, IsServerMessage o) =>
o -> m [TlsCertificateFlags]
getServerMessageTlsPeerCertificateErrors o
obj = IO [TlsCertificateFlags] -> m [TlsCertificateFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO [TlsCertificateFlags] -> m [TlsCertificateFlags])
-> IO [TlsCertificateFlags] -> m [TlsCertificateFlags]
forall a b. (a -> b) -> a -> b
$ o -> String -> IO [TlsCertificateFlags]
forall a b.
(GObject a, IsGFlag b, BoxedFlags b) =>
a -> String -> IO [b]
B.Properties.getObjectPropertyFlags o
obj String
"tls-peer-certificate-errors"

#if defined(ENABLE_OVERLOADING)
data ServerMessageTlsPeerCertificateErrorsPropertyInfo
instance AttrInfo ServerMessageTlsPeerCertificateErrorsPropertyInfo where
    type AttrAllowedOps ServerMessageTlsPeerCertificateErrorsPropertyInfo = '[ 'AttrGet]
    type AttrBaseTypeConstraint ServerMessageTlsPeerCertificateErrorsPropertyInfo = IsServerMessage
    type AttrSetTypeConstraint ServerMessageTlsPeerCertificateErrorsPropertyInfo = (~) ()
    type AttrTransferTypeConstraint ServerMessageTlsPeerCertificateErrorsPropertyInfo = (~) ()
    type AttrTransferType ServerMessageTlsPeerCertificateErrorsPropertyInfo = ()
    type AttrGetType ServerMessageTlsPeerCertificateErrorsPropertyInfo = [Gio.Flags.TlsCertificateFlags]
    type AttrLabel ServerMessageTlsPeerCertificateErrorsPropertyInfo = "tls-peer-certificate-errors"
    type AttrOrigin ServerMessageTlsPeerCertificateErrorsPropertyInfo = ServerMessage
    attrGet = getServerMessageTlsPeerCertificateErrors
    attrSet = undefined
    attrTransfer _ = undefined
    attrConstruct = undefined
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.tlsPeerCertificateErrors"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#g:attr:tlsPeerCertificateErrors"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList ServerMessage
type instance O.AttributeList ServerMessage = ServerMessageAttributeList
type ServerMessageAttributeList = ('[ '("tlsPeerCertificate", ServerMessageTlsPeerCertificatePropertyInfo), '("tlsPeerCertificateErrors", ServerMessageTlsPeerCertificateErrorsPropertyInfo)] :: [(Symbol, DK.Type)])
#endif

#if defined(ENABLE_OVERLOADING)
serverMessageTlsPeerCertificate :: AttrLabelProxy "tlsPeerCertificate"
serverMessageTlsPeerCertificate = AttrLabelProxy

serverMessageTlsPeerCertificateErrors :: AttrLabelProxy "tlsPeerCertificateErrors"
serverMessageTlsPeerCertificateErrors = AttrLabelProxy

#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList ServerMessage = ServerMessageSignalList
type ServerMessageSignalList = ('[ '("acceptCertificate", ServerMessageAcceptCertificateSignalInfo), '("connected", ServerMessageConnectedSignalInfo), '("disconnected", ServerMessageDisconnectedSignalInfo), '("finished", ServerMessageFinishedSignalInfo), '("gotBody", ServerMessageGotBodySignalInfo), '("gotChunk", ServerMessageGotChunkSignalInfo), '("gotHeaders", ServerMessageGotHeadersSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("wroteBody", ServerMessageWroteBodySignalInfo), '("wroteBodyData", ServerMessageWroteBodyDataSignalInfo), '("wroteChunk", ServerMessageWroteChunkSignalInfo), '("wroteHeaders", ServerMessageWroteHeadersSignalInfo), '("wroteInformational", ServerMessageWroteInformationalSignalInfo)] :: [(Symbol, DK.Type)])

#endif

-- method ServerMessage::get_http_version
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "HTTPVersion" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_http_version" soup_server_message_get_http_version :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO CUInt

-- | Get the HTTP version of /@msg@/.
serverMessageGetHttpVersion ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m Soup.Enums.HTTPVersion
    -- ^ __Returns:__ a t'GI.Soup.Enums.HTTPVersion'.
serverMessageGetHttpVersion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m HTTPVersion
serverMessageGetHttpVersion a
msg = IO HTTPVersion -> m HTTPVersion
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO HTTPVersion -> m HTTPVersion)
-> IO HTTPVersion -> m HTTPVersion
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CUInt
result <- Ptr ServerMessage -> IO CUInt
soup_server_message_get_http_version Ptr ServerMessage
msg'
    let result' :: HTTPVersion
result' = (Int -> HTTPVersion
forall a. Enum a => Int -> a
toEnum (Int -> HTTPVersion) -> (CUInt -> Int) -> CUInt -> HTTPVersion
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    HTTPVersion -> IO HTTPVersion
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return HTTPVersion
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetHttpVersionMethodInfo
instance (signature ~ (m Soup.Enums.HTTPVersion), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetHttpVersionMethodInfo a signature where
    overloadedMethod = serverMessageGetHttpVersion

instance O.OverloadedMethodInfo ServerMessageGetHttpVersionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetHttpVersion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetHttpVersion"
        })


#endif

-- method ServerMessage::get_local_address
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gio" , name = "SocketAddress" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_local_address" soup_server_message_get_local_address :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Gio.SocketAddress.SocketAddress)

-- | Retrieves the t'GI.Gio.Objects.SocketAddress.SocketAddress' associated with the local end
-- of a connection.
serverMessageGetLocalAddress ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m (Maybe Gio.SocketAddress.SocketAddress)
    -- ^ __Returns:__ the t'GI.Gio.Objects.SocketAddress.SocketAddress'
    --   associated with the local end of a connection, it may be
    --   'P.Nothing' if you used [method/@server@/.accept_iostream].
serverMessageGetLocalAddress :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m (Maybe SocketAddress)
serverMessageGetLocalAddress a
msg = IO (Maybe SocketAddress) -> m (Maybe SocketAddress)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SocketAddress) -> m (Maybe SocketAddress))
-> IO (Maybe SocketAddress) -> m (Maybe SocketAddress)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr SocketAddress
result <- Ptr ServerMessage -> IO (Ptr SocketAddress)
soup_server_message_get_local_address Ptr ServerMessage
msg'
    Maybe SocketAddress
maybeResult <- Ptr SocketAddress
-> (Ptr SocketAddress -> IO SocketAddress)
-> IO (Maybe SocketAddress)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr SocketAddress
result ((Ptr SocketAddress -> IO SocketAddress)
 -> IO (Maybe SocketAddress))
-> (Ptr SocketAddress -> IO SocketAddress)
-> IO (Maybe SocketAddress)
forall a b. (a -> b) -> a -> b
$ \Ptr SocketAddress
result' -> do
        SocketAddress
result'' <- ((ManagedPtr SocketAddress -> SocketAddress)
-> Ptr SocketAddress -> IO SocketAddress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SocketAddress -> SocketAddress
Gio.SocketAddress.SocketAddress) Ptr SocketAddress
result'
        SocketAddress -> IO SocketAddress
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SocketAddress
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe SocketAddress -> IO (Maybe SocketAddress)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SocketAddress
maybeResult

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetLocalAddressMethodInfo
instance (signature ~ (m (Maybe Gio.SocketAddress.SocketAddress)), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetLocalAddressMethodInfo a signature where
    overloadedMethod = serverMessageGetLocalAddress

instance O.OverloadedMethodInfo ServerMessageGetLocalAddressMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetLocalAddress",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetLocalAddress"
        })


#endif

-- method ServerMessage::get_method
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_method" soup_server_message_get_method :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO CString

-- | Get the HTTP method of /@msg@/.
serverMessageGetMethod ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m T.Text
    -- ^ __Returns:__ the HTTP method.
serverMessageGetMethod :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m Text
serverMessageGetMethod a
msg = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
result <- Ptr ServerMessage -> IO CString
soup_server_message_get_method Ptr ServerMessage
msg'
    Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serverMessageGetMethod" CString
result
    Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetMethodMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetMethodMethodInfo a signature where
    overloadedMethod = serverMessageGetMethod

instance O.OverloadedMethodInfo ServerMessageGetMethodMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetMethod",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetMethod"
        })


#endif

-- method ServerMessage::get_reason_phrase
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage:"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_reason_phrase" soup_server_message_get_reason_phrase :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO CString

-- | Get the HTTP reason phrase of /@msg@/.
serverMessageGetReasonPhrase ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage':
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the reason phrase.
serverMessageGetReasonPhrase :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m (Maybe Text)
serverMessageGetReasonPhrase a
msg = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
result <- Ptr ServerMessage -> IO CString
soup_server_message_get_reason_phrase Ptr ServerMessage
msg'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetReasonPhraseMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetReasonPhraseMethodInfo a signature where
    overloadedMethod = serverMessageGetReasonPhrase

instance O.OverloadedMethodInfo ServerMessageGetReasonPhraseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetReasonPhrase",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetReasonPhrase"
        })


#endif

-- method ServerMessage::get_remote_address
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gio" , name = "SocketAddress" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_remote_address" soup_server_message_get_remote_address :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Gio.SocketAddress.SocketAddress)

-- | Retrieves the t'GI.Gio.Objects.SocketAddress.SocketAddress' associated with the remote end
-- of a connection.
serverMessageGetRemoteAddress ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m (Maybe Gio.SocketAddress.SocketAddress)
    -- ^ __Returns:__ the t'GI.Gio.Objects.SocketAddress.SocketAddress'
    --   associated with the remote end of a connection, it may be
    --   'P.Nothing' if you used @/Server.accept_iostream/@.
serverMessageGetRemoteAddress :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m (Maybe SocketAddress)
serverMessageGetRemoteAddress a
msg = IO (Maybe SocketAddress) -> m (Maybe SocketAddress)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe SocketAddress) -> m (Maybe SocketAddress))
-> IO (Maybe SocketAddress) -> m (Maybe SocketAddress)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr SocketAddress
result <- Ptr ServerMessage -> IO (Ptr SocketAddress)
soup_server_message_get_remote_address Ptr ServerMessage
msg'
    Maybe SocketAddress
maybeResult <- Ptr SocketAddress
-> (Ptr SocketAddress -> IO SocketAddress)
-> IO (Maybe SocketAddress)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr SocketAddress
result ((Ptr SocketAddress -> IO SocketAddress)
 -> IO (Maybe SocketAddress))
-> (Ptr SocketAddress -> IO SocketAddress)
-> IO (Maybe SocketAddress)
forall a b. (a -> b) -> a -> b
$ \Ptr SocketAddress
result' -> do
        SocketAddress
result'' <- ((ManagedPtr SocketAddress -> SocketAddress)
-> Ptr SocketAddress -> IO SocketAddress
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr SocketAddress -> SocketAddress
Gio.SocketAddress.SocketAddress) Ptr SocketAddress
result'
        SocketAddress -> IO SocketAddress
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SocketAddress
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe SocketAddress -> IO (Maybe SocketAddress)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe SocketAddress
maybeResult

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetRemoteAddressMethodInfo
instance (signature ~ (m (Maybe Gio.SocketAddress.SocketAddress)), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetRemoteAddressMethodInfo a signature where
    overloadedMethod = serverMessageGetRemoteAddress

instance O.OverloadedMethodInfo ServerMessageGetRemoteAddressMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetRemoteAddress",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetRemoteAddress"
        })


#endif

-- method ServerMessage::get_remote_host
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_remote_host" soup_server_message_get_remote_host :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO CString

-- | Retrieves the IP address associated with the remote end of a
-- connection.
serverMessageGetRemoteHost ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ the IP address associated with the remote
    --   end of a connection, it may be 'P.Nothing' if you used
    --   [method/@server@/.accept_iostream].
serverMessageGetRemoteHost :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m (Maybe Text)
serverMessageGetRemoteHost a
msg = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
result <- Ptr ServerMessage -> IO CString
soup_server_message_get_remote_host Ptr ServerMessage
msg'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetRemoteHostMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetRemoteHostMethodInfo a signature where
    overloadedMethod = serverMessageGetRemoteHost

instance O.OverloadedMethodInfo ServerMessageGetRemoteHostMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetRemoteHost",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetRemoteHost"
        })


#endif

-- method ServerMessage::get_request_body
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "MessageBody" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_request_body" soup_server_message_get_request_body :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Soup.MessageBody.MessageBody)

-- | Get the request body of /@msg@/.
serverMessageGetRequestBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m Soup.MessageBody.MessageBody
    -- ^ __Returns:__ a t'GI.Soup.Structs.MessageBody.MessageBody'.
serverMessageGetRequestBody :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m MessageBody
serverMessageGetRequestBody a
msg = IO MessageBody -> m MessageBody
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageBody -> m MessageBody)
-> IO MessageBody -> m MessageBody
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr MessageBody
result <- Ptr ServerMessage -> IO (Ptr MessageBody)
soup_server_message_get_request_body Ptr ServerMessage
msg'
    Text -> Ptr MessageBody -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serverMessageGetRequestBody" Ptr MessageBody
result
    MessageBody
result' <- ((ManagedPtr MessageBody -> MessageBody)
-> Ptr MessageBody -> IO MessageBody
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageBody -> MessageBody
Soup.MessageBody.MessageBody) Ptr MessageBody
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    MessageBody -> IO MessageBody
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageBody
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetRequestBodyMethodInfo
instance (signature ~ (m Soup.MessageBody.MessageBody), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetRequestBodyMethodInfo a signature where
    overloadedMethod = serverMessageGetRequestBody

instance O.OverloadedMethodInfo ServerMessageGetRequestBodyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetRequestBody",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetRequestBody"
        })


#endif

-- method ServerMessage::get_request_headers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "MessageHeaders" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_request_headers" soup_server_message_get_request_headers :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Soup.MessageHeaders.MessageHeaders)

-- | Get the request headers of /@msg@/.
serverMessageGetRequestHeaders ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m Soup.MessageHeaders.MessageHeaders
    -- ^ __Returns:__ a t'GI.Soup.Structs.MessageHeaders.MessageHeaders' with the request headers.
serverMessageGetRequestHeaders :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m MessageHeaders
serverMessageGetRequestHeaders a
msg = IO MessageHeaders -> m MessageHeaders
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeaders -> m MessageHeaders)
-> IO MessageHeaders -> m MessageHeaders
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr MessageHeaders
result <- Ptr ServerMessage -> IO (Ptr MessageHeaders)
soup_server_message_get_request_headers Ptr ServerMessage
msg'
    Text -> Ptr MessageHeaders -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serverMessageGetRequestHeaders" Ptr MessageHeaders
result
    MessageHeaders
result' <- ((ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageHeaders -> MessageHeaders
Soup.MessageHeaders.MessageHeaders) Ptr MessageHeaders
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    MessageHeaders -> IO MessageHeaders
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeaders
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetRequestHeadersMethodInfo
instance (signature ~ (m Soup.MessageHeaders.MessageHeaders), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetRequestHeadersMethodInfo a signature where
    overloadedMethod = serverMessageGetRequestHeaders

instance O.OverloadedMethodInfo ServerMessageGetRequestHeadersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetRequestHeaders",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetRequestHeaders"
        })


#endif

-- method ServerMessage::get_response_body
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "MessageBody" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_response_body" soup_server_message_get_response_body :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Soup.MessageBody.MessageBody)

-- | Get the response body of /@msg@/.
serverMessageGetResponseBody ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m Soup.MessageBody.MessageBody
    -- ^ __Returns:__ a t'GI.Soup.Structs.MessageBody.MessageBody'.
serverMessageGetResponseBody :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m MessageBody
serverMessageGetResponseBody a
msg = IO MessageBody -> m MessageBody
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageBody -> m MessageBody)
-> IO MessageBody -> m MessageBody
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr MessageBody
result <- Ptr ServerMessage -> IO (Ptr MessageBody)
soup_server_message_get_response_body Ptr ServerMessage
msg'
    Text -> Ptr MessageBody -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serverMessageGetResponseBody" Ptr MessageBody
result
    MessageBody
result' <- ((ManagedPtr MessageBody -> MessageBody)
-> Ptr MessageBody -> IO MessageBody
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageBody -> MessageBody
Soup.MessageBody.MessageBody) Ptr MessageBody
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    MessageBody -> IO MessageBody
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageBody
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetResponseBodyMethodInfo
instance (signature ~ (m Soup.MessageBody.MessageBody), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetResponseBodyMethodInfo a signature where
    overloadedMethod = serverMessageGetResponseBody

instance O.OverloadedMethodInfo ServerMessageGetResponseBodyMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetResponseBody",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetResponseBody"
        })


#endif

-- method ServerMessage::get_response_headers
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Soup" , name = "MessageHeaders" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_response_headers" soup_server_message_get_response_headers :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Soup.MessageHeaders.MessageHeaders)

-- | Get the response headers of /@msg@/.
serverMessageGetResponseHeaders ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m Soup.MessageHeaders.MessageHeaders
    -- ^ __Returns:__ a t'GI.Soup.Structs.MessageHeaders.MessageHeaders' with the response headers.
serverMessageGetResponseHeaders :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m MessageHeaders
serverMessageGetResponseHeaders a
msg = IO MessageHeaders -> m MessageHeaders
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MessageHeaders -> m MessageHeaders)
-> IO MessageHeaders -> m MessageHeaders
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr MessageHeaders
result <- Ptr ServerMessage -> IO (Ptr MessageHeaders)
soup_server_message_get_response_headers Ptr ServerMessage
msg'
    Text -> Ptr MessageHeaders -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serverMessageGetResponseHeaders" Ptr MessageHeaders
result
    MessageHeaders
result' <- ((ManagedPtr MessageHeaders -> MessageHeaders)
-> Ptr MessageHeaders -> IO MessageHeaders
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr MessageHeaders -> MessageHeaders
Soup.MessageHeaders.MessageHeaders) Ptr MessageHeaders
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    MessageHeaders -> IO MessageHeaders
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return MessageHeaders
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetResponseHeadersMethodInfo
instance (signature ~ (m Soup.MessageHeaders.MessageHeaders), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetResponseHeadersMethodInfo a signature where
    overloadedMethod = serverMessageGetResponseHeaders

instance O.OverloadedMethodInfo ServerMessageGetResponseHeadersMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetResponseHeaders",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetResponseHeaders"
        })


#endif

-- method ServerMessage::get_socket
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "Socket" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_socket" soup_server_message_get_socket :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Gio.Socket.Socket)

-- | Retrieves the t'GI.Gio.Objects.Socket.Socket' that /@msg@/ is associated with.
-- 
-- If you are using this method to observe when multiple requests are
-- made on the same persistent HTTP connection (eg, as the ntlm-test
-- test program does), you will need to pay attention to socket
-- destruction as well (eg, by using weak references), so that you do
-- not get fooled when the allocator reuses the memory address of a
-- previously-destroyed socket to represent a new socket.
serverMessageGetSocket ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m (Maybe Gio.Socket.Socket)
    -- ^ __Returns:__ the t'GI.Gio.Objects.Socket.Socket' that /@msg@/ is
    --   associated with, 'P.Nothing' if you used [method/@server@/.accept_iostream].
serverMessageGetSocket :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m (Maybe Socket)
serverMessageGetSocket a
msg = IO (Maybe Socket) -> m (Maybe Socket)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Socket) -> m (Maybe Socket))
-> IO (Maybe Socket) -> m (Maybe Socket)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Socket
result <- Ptr ServerMessage -> IO (Ptr Socket)
soup_server_message_get_socket Ptr ServerMessage
msg'
    Maybe Socket
maybeResult <- Ptr Socket -> (Ptr Socket -> IO Socket) -> IO (Maybe Socket)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Socket
result ((Ptr Socket -> IO Socket) -> IO (Maybe Socket))
-> (Ptr Socket -> IO Socket) -> IO (Maybe Socket)
forall a b. (a -> b) -> a -> b
$ \Ptr Socket
result' -> do
        Socket
result'' <- ((ManagedPtr Socket -> Socket) -> Ptr Socket -> IO Socket
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Socket -> Socket
Gio.Socket.Socket) Ptr Socket
result'
        Socket -> IO Socket
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Socket
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe Socket -> IO (Maybe Socket)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Socket
maybeResult

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetSocketMethodInfo
instance (signature ~ (m (Maybe Gio.Socket.Socket)), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetSocketMethodInfo a signature where
    overloadedMethod = serverMessageGetSocket

instance O.OverloadedMethodInfo ServerMessageGetSocketMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetSocket",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetSocket"
        })


#endif

-- method ServerMessage::get_status
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUInt)
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_status" soup_server_message_get_status :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO Word32

-- | Get the HTTP status code of /@msg@/.
serverMessageGetStatus ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m Word32
    -- ^ __Returns:__ the HTTP status code.
serverMessageGetStatus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m Word32
serverMessageGetStatus a
msg = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Word32
result <- Ptr ServerMessage -> IO Word32
soup_server_message_get_status Ptr ServerMessage
msg'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetStatusMethodInfo
instance (signature ~ (m Word32), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetStatusMethodInfo a signature where
    overloadedMethod = serverMessageGetStatus

instance O.OverloadedMethodInfo ServerMessageGetStatusMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetStatus",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetStatus"
        })


#endif

-- method ServerMessage::get_tls_peer_certificate
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface Name { namespace = "Gio" , name = "TlsCertificate" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_tls_peer_certificate" soup_server_message_get_tls_peer_certificate :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Gio.TlsCertificate.TlsCertificate)

-- | Gets the peer\'s t'GI.Gio.Objects.TlsCertificate.TlsCertificate' associated with /@msg@/\'s connection.
-- Note that this is not set yet during the emission of
-- SoupServerMessage[acceptCertificate](#g:signal:acceptCertificate) signal.
-- 
-- /Since: 3.2/
serverMessageGetTlsPeerCertificate ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m (Maybe Gio.TlsCertificate.TlsCertificate)
    -- ^ __Returns:__ /@msg@/\'s TLS peer certificate,
    --    or 'P.Nothing' if /@msg@/\'s connection is not SSL.
serverMessageGetTlsPeerCertificate :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m (Maybe TlsCertificate)
serverMessageGetTlsPeerCertificate a
msg = IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate))
-> IO (Maybe TlsCertificate) -> m (Maybe TlsCertificate)
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr TlsCertificate
result <- Ptr ServerMessage -> IO (Ptr TlsCertificate)
soup_server_message_get_tls_peer_certificate Ptr ServerMessage
msg'
    Maybe TlsCertificate
maybeResult <- Ptr TlsCertificate
-> (Ptr TlsCertificate -> IO TlsCertificate)
-> IO (Maybe TlsCertificate)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr TlsCertificate
result ((Ptr TlsCertificate -> IO TlsCertificate)
 -> IO (Maybe TlsCertificate))
-> (Ptr TlsCertificate -> IO TlsCertificate)
-> IO (Maybe TlsCertificate)
forall a b. (a -> b) -> a -> b
$ \Ptr TlsCertificate
result' -> do
        TlsCertificate
result'' <- ((ManagedPtr TlsCertificate -> TlsCertificate)
-> Ptr TlsCertificate -> IO TlsCertificate
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr TlsCertificate -> TlsCertificate
Gio.TlsCertificate.TlsCertificate) Ptr TlsCertificate
result'
        TlsCertificate -> IO TlsCertificate
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TlsCertificate
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Maybe TlsCertificate -> IO (Maybe TlsCertificate)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TlsCertificate
maybeResult

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetTlsPeerCertificateMethodInfo
instance (signature ~ (m (Maybe Gio.TlsCertificate.TlsCertificate)), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetTlsPeerCertificateMethodInfo a signature where
    overloadedMethod = serverMessageGetTlsPeerCertificate

instance O.OverloadedMethodInfo ServerMessageGetTlsPeerCertificateMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetTlsPeerCertificate",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetTlsPeerCertificate"
        })


#endif

-- method ServerMessage::get_tls_peer_certificate_errors
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupMessage" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gio" , name = "TlsCertificateFlags" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_tls_peer_certificate_errors" soup_server_message_get_tls_peer_certificate_errors :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO CUInt

-- | Gets the errors associated with validating /@msg@/\'s TLS peer certificate.
-- Note that this is not set yet during the emission of
-- SoupServerMessage[acceptCertificate](#g:signal:acceptCertificate) signal.
-- 
-- /Since: 3.2/
serverMessageGetTlsPeerCertificateErrors ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.Message.Message'
    -> m [Gio.Flags.TlsCertificateFlags]
    -- ^ __Returns:__ a t'GI.Gio.Flags.TlsCertificateFlags' with /@msg@/\'s TLS peer certificate errors.
serverMessageGetTlsPeerCertificateErrors :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m [TlsCertificateFlags]
serverMessageGetTlsPeerCertificateErrors a
msg = IO [TlsCertificateFlags] -> m [TlsCertificateFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [TlsCertificateFlags] -> m [TlsCertificateFlags])
-> IO [TlsCertificateFlags] -> m [TlsCertificateFlags]
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CUInt
result <- Ptr ServerMessage -> IO CUInt
soup_server_message_get_tls_peer_certificate_errors Ptr ServerMessage
msg'
    let result' :: [TlsCertificateFlags]
result' = CUInt -> [TlsCertificateFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    [TlsCertificateFlags] -> IO [TlsCertificateFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [TlsCertificateFlags]
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetTlsPeerCertificateErrorsMethodInfo
instance (signature ~ (m [Gio.Flags.TlsCertificateFlags]), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetTlsPeerCertificateErrorsMethodInfo a signature where
    overloadedMethod = serverMessageGetTlsPeerCertificateErrors

instance O.OverloadedMethodInfo ServerMessageGetTlsPeerCertificateErrorsMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetTlsPeerCertificateErrors",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetTlsPeerCertificateErrors"
        })


#endif

-- method ServerMessage::get_uri
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "GLib" , name = "Uri" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_get_uri" soup_server_message_get_uri :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr GLib.Uri.Uri)

-- | Get /@msg@/\'s URI.
serverMessageGetUri ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m GLib.Uri.Uri
    -- ^ __Returns:__ a t'GI.GLib.Structs.Uri.Uri'
serverMessageGetUri :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m Uri
serverMessageGetUri a
msg = IO Uri -> m Uri
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Uri -> m Uri) -> IO Uri -> m Uri
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr Uri
result <- Ptr ServerMessage -> IO (Ptr Uri)
soup_server_message_get_uri Ptr ServerMessage
msg'
    Text -> Ptr Uri -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serverMessageGetUri" Ptr Uri
result
    Uri
result' <- ((ManagedPtr Uri -> Uri) -> Ptr Uri -> IO Uri
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Uri -> Uri
GLib.Uri.Uri) Ptr Uri
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Uri -> IO Uri
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Uri
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageGetUriMethodInfo
instance (signature ~ (m GLib.Uri.Uri), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageGetUriMethodInfo a signature where
    overloadedMethod = serverMessageGetUri

instance O.OverloadedMethodInfo ServerMessageGetUriMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageGetUri",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageGetUri"
        })


#endif

-- method ServerMessage::is_options_ping
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_is_options_ping" soup_server_message_is_options_ping :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO CInt

-- | Gets if /@msg@/ represents an OPTIONS message with the path @*@.
serverMessageIsOptionsPing ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if is an OPTIONS ping
serverMessageIsOptionsPing :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m Bool
serverMessageIsOptionsPing a
msg = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CInt
result <- Ptr ServerMessage -> IO CInt
soup_server_message_is_options_ping Ptr ServerMessage
msg'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageIsOptionsPingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageIsOptionsPingMethodInfo a signature where
    overloadedMethod = serverMessageIsOptionsPing

instance O.OverloadedMethodInfo ServerMessageIsOptionsPingMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageIsOptionsPing",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageIsOptionsPing"
        })


#endif

-- method ServerMessage::pause
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_pause" soup_server_message_pause :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO ()

-- | Pauses I\/O on /@msg@/.
-- 
-- This can be used when you need to return from the server handler without
-- having the full response ready yet. Use [method/@serverMessage@/.unpause] to
-- resume I\/O.
-- 
-- /Since: 3.2/
serverMessagePause ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a SoupServerMessage
    -> m ()
serverMessagePause :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m ()
serverMessagePause a
msg = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr ServerMessage -> IO ()
soup_server_message_pause Ptr ServerMessage
msg'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ServerMessagePauseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessagePauseMethodInfo a signature where
    overloadedMethod = serverMessagePause

instance O.OverloadedMethodInfo ServerMessagePauseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessagePause",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessagePause"
        })


#endif

-- method ServerMessage::set_http_version
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "version"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "HTTPVersion" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupHTTPVersion" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_set_http_version" soup_server_message_set_http_version :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    CUInt ->                                -- version : TInterface (Name {namespace = "Soup", name = "HTTPVersion"})
    IO ()

-- | Set the HTTP version of /@msg@/.
serverMessageSetHttpVersion ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> Soup.Enums.HTTPVersion
    -- ^ /@version@/: a t'GI.Soup.Enums.HTTPVersion'
    -> m ()
serverMessageSetHttpVersion :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> HTTPVersion -> m ()
serverMessageSetHttpVersion a
msg HTTPVersion
version = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    let version' :: CUInt
version' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (HTTPVersion -> Int) -> HTTPVersion -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HTTPVersion -> Int
forall a. Enum a => a -> Int
fromEnum) HTTPVersion
version
    Ptr ServerMessage -> CUInt -> IO ()
soup_server_message_set_http_version Ptr ServerMessage
msg' CUInt
version'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ServerMessageSetHttpVersionMethodInfo
instance (signature ~ (Soup.Enums.HTTPVersion -> m ()), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageSetHttpVersionMethodInfo a signature where
    overloadedMethod = serverMessageSetHttpVersion

instance O.OverloadedMethodInfo ServerMessageSetHttpVersionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageSetHttpVersion",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageSetHttpVersion"
        })


#endif

-- method ServerMessage::set_redirect
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "status_code"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a 3xx status code" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "redirect_uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the URI to redirect @msg to"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_set_redirect" soup_server_message_set_redirect :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    Word32 ->                               -- status_code : TBasicType TUInt
    CString ->                              -- redirect_uri : TBasicType TUTF8
    IO ()

-- | Sets /@msg@/\'s status_code to /@statusCode@/ and adds a Location header
-- pointing to /@redirectUri@/. Use this from a [class/@server@/] when you
-- want to redirect the client to another URI.
-- 
-- /@redirectUri@/ can be a relative URI, in which case it is
-- interpreted relative to /@msg@/\'s current URI. In particular, if
-- /@redirectUri@/ is just a path, it will replace the path
-- *and query* of /@msg@/\'s URI.
serverMessageSetRedirect ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> Word32
    -- ^ /@statusCode@/: a 3xx status code
    -> T.Text
    -- ^ /@redirectUri@/: the URI to redirect /@msg@/ to
    -> m ()
serverMessageSetRedirect :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> Word32 -> Text -> m ()
serverMessageSetRedirect a
msg Word32
statusCode Text
redirectUri = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
redirectUri' <- Text -> IO CString
textToCString Text
redirectUri
    Ptr ServerMessage -> Word32 -> CString -> IO ()
soup_server_message_set_redirect Ptr ServerMessage
msg' Word32
statusCode CString
redirectUri'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
redirectUri'
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ServerMessageSetRedirectMethodInfo
instance (signature ~ (Word32 -> T.Text -> m ()), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageSetRedirectMethodInfo a signature where
    overloadedMethod = serverMessageSetRedirect

instance O.OverloadedMethodInfo ServerMessageSetRedirectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageSetRedirect",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageSetRedirect"
        })


#endif

-- method ServerMessage::set_response
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the message" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "content_type"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "MIME Content-Type of the body"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resp_use"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "MemoryUse" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just "a #SoupMemoryUse describing how to handle @resp_body"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resp_body"
--           , argType = TCArray False (-1) 4 (TBasicType TUInt8)
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "\n  a data buffer containing the body of the message response."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "resp_length"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the byte length of @resp_body."
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: [ Arg
--              { argCName = "resp_length"
--              , argType = TBasicType TUInt64
--              , direction = DirectionIn
--              , mayBeNull = False
--              , argDoc =
--                  Documentation
--                    { rawDocText = Just "the byte length of @resp_body."
--                    , sinceVersion = Nothing
--                    }
--              , argScope = ScopeTypeInvalid
--              , argClosure = -1
--              , argDestroy = -1
--              , argCallerAllocates = False
--              , transfer = TransferNothing
--              }
--          ]
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_set_response" soup_server_message_set_response :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    CString ->                              -- content_type : TBasicType TUTF8
    CUInt ->                                -- resp_use : TInterface (Name {namespace = "Soup", name = "MemoryUse"})
    Ptr Word8 ->                            -- resp_body : TCArray False (-1) 4 (TBasicType TUInt8)
    Word64 ->                               -- resp_length : TBasicType TUInt64
    IO ()

-- | Convenience function to set the response body of a t'GI.Soup.Objects.ServerMessage.ServerMessage'. If
-- /@contentType@/ is 'P.Nothing', the response body must be empty as well.
serverMessageSetResponse ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: the message
    -> Maybe (T.Text)
    -- ^ /@contentType@/: MIME Content-Type of the body
    -> Soup.Enums.MemoryUse
    -- ^ /@respUse@/: a t'GI.Soup.Enums.MemoryUse' describing how to handle /@respBody@/
    -> Maybe (ByteString)
    -- ^ /@respBody@/: 
    --   a data buffer containing the body of the message response.
    -> m ()
serverMessageSetResponse :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> Maybe Text -> MemoryUse -> Maybe ByteString -> m ()
serverMessageSetResponse a
msg Maybe Text
contentType MemoryUse
respUse Maybe ByteString
respBody = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    let respLength :: Word64
respLength = case Maybe ByteString
respBody of
            Maybe ByteString
Nothing -> Word64
0
            Just ByteString
jRespBody -> Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word64) -> Int -> Word64
forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
jRespBody
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
maybeContentType <- case Maybe Text
contentType of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jContentType -> do
            CString
jContentType' <- Text -> IO CString
textToCString Text
jContentType
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jContentType'
    let respUse' :: CUInt
respUse' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (MemoryUse -> Int) -> MemoryUse -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MemoryUse -> Int
forall a. Enum a => a -> Int
fromEnum) MemoryUse
respUse
    Ptr Word8
maybeRespBody <- case Maybe ByteString
respBody of
        Maybe ByteString
Nothing -> Ptr Word8 -> IO (Ptr Word8)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
forall a. Ptr a
nullPtr
        Just ByteString
jRespBody -> do
            Ptr Word8
jRespBody' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
jRespBody
            Ptr Word8 -> IO (Ptr Word8)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
jRespBody'
    Ptr ServerMessage
-> CString -> CUInt -> Ptr Word8 -> Word64 -> IO ()
soup_server_message_set_response Ptr ServerMessage
msg' CString
maybeContentType CUInt
respUse' Ptr Word8
maybeRespBody Word64
respLength
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeContentType
    Ptr Word8 -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Word8
maybeRespBody
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ServerMessageSetResponseMethodInfo
instance (signature ~ (Maybe (T.Text) -> Soup.Enums.MemoryUse -> Maybe (ByteString) -> m ()), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageSetResponseMethodInfo a signature where
    overloadedMethod = serverMessageSetResponse

instance O.OverloadedMethodInfo ServerMessageSetResponseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageSetResponse",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageSetResponse"
        })


#endif

-- method ServerMessage::set_status
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "status_code"
--           , argType = TBasicType TUInt
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "an HTTP status code"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "reason_phrase"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a reason phrase" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_set_status" soup_server_message_set_status :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    Word32 ->                               -- status_code : TBasicType TUInt
    CString ->                              -- reason_phrase : TBasicType TUTF8
    IO ()

-- | Sets /@msg@/\'s status code to /@statusCode@/.
-- 
-- If /@statusCode@/ is a known value and /@reasonPhrase@/ is 'P.Nothing', the
-- reason_phrase will be set automatically.
serverMessageSetStatus ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> Word32
    -- ^ /@statusCode@/: an HTTP status code
    -> Maybe (T.Text)
    -- ^ /@reasonPhrase@/: a reason phrase
    -> m ()
serverMessageSetStatus :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> Word32 -> Maybe Text -> m ()
serverMessageSetStatus a
msg Word32
statusCode Maybe Text
reasonPhrase = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    CString
maybeReasonPhrase <- case Maybe Text
reasonPhrase of
        Maybe Text
Nothing -> CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
forall a. Ptr a
nullPtr
        Just Text
jReasonPhrase -> do
            CString
jReasonPhrase' <- Text -> IO CString
textToCString Text
jReasonPhrase
            CString -> IO CString
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CString
jReasonPhrase'
    Ptr ServerMessage -> Word32 -> CString -> IO ()
soup_server_message_set_status Ptr ServerMessage
msg' Word32
statusCode CString
maybeReasonPhrase
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
maybeReasonPhrase
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ServerMessageSetStatusMethodInfo
instance (signature ~ (Word32 -> Maybe (T.Text) -> m ()), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageSetStatusMethodInfo a signature where
    overloadedMethod = serverMessageSetStatus

instance O.OverloadedMethodInfo ServerMessageSetStatusMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageSetStatus",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageSetStatus"
        })


#endif

-- method ServerMessage::steal_connection
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Gio" , name = "IOStream" })
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_steal_connection" soup_server_message_steal_connection :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO (Ptr Gio.IOStream.IOStream)

-- | \"Steals\" the HTTP connection associated with /@msg@/ from its t'GI.Soup.Objects.Server.Server'. This
-- happens immediately, regardless of the current state of the connection; if
-- the response to /@msg@/ has not yet finished being sent, then it will be
-- discarded; you can steal the connection from a
-- [signal/@serverMessage@/[wroteInformational](#g:signal:wroteInformational)] or
-- [signal/@serverMessage@/[wroteBody](#g:signal:wroteBody)] signal handler if you need to wait for
-- part or all of the response to be sent.
-- 
-- Note that when calling this function from C, /@msg@/ will most
-- likely be freed as a side effect.
serverMessageStealConnection ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a t'GI.Soup.Objects.ServerMessage.ServerMessage'
    -> m Gio.IOStream.IOStream
    -- ^ __Returns:__ the t'GI.Gio.Objects.IOStream.IOStream' formerly associated
    --   with /@msg@/ (or 'P.Nothing' if /@msg@/ was no longer associated with a
    --   connection). No guarantees are made about what kind of t'GI.Gio.Objects.IOStream.IOStream'
    --   is returned.
serverMessageStealConnection :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m IOStream
serverMessageStealConnection a
msg = IO IOStream -> m IOStream
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO IOStream -> m IOStream) -> IO IOStream -> m IOStream
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr IOStream
result <- Ptr ServerMessage -> IO (Ptr IOStream)
soup_server_message_steal_connection Ptr ServerMessage
msg'
    Text -> Ptr IOStream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"serverMessageStealConnection" Ptr IOStream
result
    IOStream
result' <- ((ManagedPtr IOStream -> IOStream) -> Ptr IOStream -> IO IOStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr IOStream -> IOStream
Gio.IOStream.IOStream) Ptr IOStream
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    IOStream -> IO IOStream
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return IOStream
result'

#if defined(ENABLE_OVERLOADING)
data ServerMessageStealConnectionMethodInfo
instance (signature ~ (m Gio.IOStream.IOStream), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageStealConnectionMethodInfo a signature where
    overloadedMethod = serverMessageStealConnection

instance O.OverloadedMethodInfo ServerMessageStealConnectionMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageStealConnection",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageStealConnection"
        })


#endif

-- method ServerMessage::unpause
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "msg"
--           , argType =
--               TInterface Name { namespace = "Soup" , name = "ServerMessage" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a SoupServerMessage"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "soup_server_message_unpause" soup_server_message_unpause :: 
    Ptr ServerMessage ->                    -- msg : TInterface (Name {namespace = "Soup", name = "ServerMessage"})
    IO ()

-- | Resumes I\/O on /@msg@/.
-- 
-- Use this to resume after calling [method/@serverMessage@/.pause], or after
-- adding a new chunk to a chunked response. I\/O won\'t actually resume until you
-- return to the main loop.
-- 
-- /Since: 3.2/
serverMessageUnpause ::
    (B.CallStack.HasCallStack, MonadIO m, IsServerMessage a) =>
    a
    -- ^ /@msg@/: a SoupServerMessage
    -> m ()
serverMessageUnpause :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsServerMessage a) =>
a -> m ()
serverMessageUnpause a
msg = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr ServerMessage
msg' <- a -> IO (Ptr ServerMessage)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
msg
    Ptr ServerMessage -> IO ()
soup_server_message_unpause Ptr ServerMessage
msg'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
msg
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data ServerMessageUnpauseMethodInfo
instance (signature ~ (m ()), MonadIO m, IsServerMessage a) => O.OverloadedMethod ServerMessageUnpauseMethodInfo a signature where
    overloadedMethod = serverMessageUnpause

instance O.OverloadedMethodInfo ServerMessageUnpauseMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Soup.Objects.ServerMessage.serverMessageUnpause",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-soup-3.0.2/docs/GI-Soup-Objects-ServerMessage.html#v:serverMessageUnpause"
        })


#endif