{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A class representing a WebSocket connection. /Since: 2.50/ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Soup.Objects.WebsocketConnection ( -- * Exported types WebsocketConnection(..) , IsWebsocketConnection , toWebsocketConnection , noWebsocketConnection , -- * Methods -- ** close #method:close# #if ENABLE_OVERLOADING WebsocketConnectionCloseMethodInfo , #endif websocketConnectionClose , -- ** getCloseCode #method:getCloseCode# #if ENABLE_OVERLOADING WebsocketConnectionGetCloseCodeMethodInfo, #endif websocketConnectionGetCloseCode , -- ** getCloseData #method:getCloseData# #if ENABLE_OVERLOADING WebsocketConnectionGetCloseDataMethodInfo, #endif websocketConnectionGetCloseData , -- ** getConnectionType #method:getConnectionType# #if ENABLE_OVERLOADING WebsocketConnectionGetConnectionTypeMethodInfo, #endif websocketConnectionGetConnectionType , -- ** getIoStream #method:getIoStream# #if ENABLE_OVERLOADING WebsocketConnectionGetIoStreamMethodInfo, #endif websocketConnectionGetIoStream , -- ** getKeepaliveInterval #method:getKeepaliveInterval# #if ENABLE_OVERLOADING WebsocketConnectionGetKeepaliveIntervalMethodInfo, #endif websocketConnectionGetKeepaliveInterval , -- ** getMaxIncomingPayloadSize #method:getMaxIncomingPayloadSize# #if ENABLE_OVERLOADING WebsocketConnectionGetMaxIncomingPayloadSizeMethodInfo, #endif websocketConnectionGetMaxIncomingPayloadSize, -- ** getOrigin #method:getOrigin# #if ENABLE_OVERLOADING WebsocketConnectionGetOriginMethodInfo , #endif websocketConnectionGetOrigin , -- ** getProtocol #method:getProtocol# #if ENABLE_OVERLOADING WebsocketConnectionGetProtocolMethodInfo, #endif websocketConnectionGetProtocol , -- ** getState #method:getState# #if ENABLE_OVERLOADING WebsocketConnectionGetStateMethodInfo , #endif websocketConnectionGetState , -- ** getUri #method:getUri# #if ENABLE_OVERLOADING WebsocketConnectionGetUriMethodInfo , #endif websocketConnectionGetUri , -- ** new #method:new# websocketConnectionNew , -- ** sendBinary #method:sendBinary# #if ENABLE_OVERLOADING WebsocketConnectionSendBinaryMethodInfo , #endif websocketConnectionSendBinary , -- ** sendText #method:sendText# #if ENABLE_OVERLOADING WebsocketConnectionSendTextMethodInfo , #endif websocketConnectionSendText , -- ** setKeepaliveInterval #method:setKeepaliveInterval# #if ENABLE_OVERLOADING WebsocketConnectionSetKeepaliveIntervalMethodInfo, #endif websocketConnectionSetKeepaliveInterval , -- ** setMaxIncomingPayloadSize #method:setMaxIncomingPayloadSize# #if ENABLE_OVERLOADING WebsocketConnectionSetMaxIncomingPayloadSizeMethodInfo, #endif websocketConnectionSetMaxIncomingPayloadSize, -- * Properties -- ** connectionType #attr:connectionType# {- | The type of connection (client\/server). /Since: 2.50/ -} #if ENABLE_OVERLOADING WebsocketConnectionConnectionTypePropertyInfo, #endif constructWebsocketConnectionConnectionType, getWebsocketConnectionConnectionType , #if ENABLE_OVERLOADING websocketConnectionConnectionType , #endif -- ** ioStream #attr:ioStream# {- | The underlying IO stream the WebSocket is communicating over. The input and output streams must be pollable streams. /Since: 2.50/ -} #if ENABLE_OVERLOADING WebsocketConnectionIoStreamPropertyInfo , #endif constructWebsocketConnectionIoStream , getWebsocketConnectionIoStream , #if ENABLE_OVERLOADING websocketConnectionIoStream , #endif -- ** keepaliveInterval #attr:keepaliveInterval# {- | Interval in seconds on when to send a ping message which will serve as a keepalive message. If set to 0 the keepalive message is disabled. /Since: 2.58/ -} #if ENABLE_OVERLOADING WebsocketConnectionKeepaliveIntervalPropertyInfo, #endif constructWebsocketConnectionKeepaliveInterval, getWebsocketConnectionKeepaliveInterval , setWebsocketConnectionKeepaliveInterval , #if ENABLE_OVERLOADING websocketConnectionKeepaliveInterval , #endif -- ** maxIncomingPayloadSize #attr:maxIncomingPayloadSize# {- | The maximum payload size for incoming packets the protocol expects or 0 to not limit it. /Since: 2.56/ -} #if ENABLE_OVERLOADING WebsocketConnectionMaxIncomingPayloadSizePropertyInfo, #endif constructWebsocketConnectionMaxIncomingPayloadSize, getWebsocketConnectionMaxIncomingPayloadSize, setWebsocketConnectionMaxIncomingPayloadSize, #if ENABLE_OVERLOADING websocketConnectionMaxIncomingPayloadSize, #endif -- ** origin #attr:origin# {- | The client\'s Origin. /Since: 2.50/ -} #if ENABLE_OVERLOADING WebsocketConnectionOriginPropertyInfo , #endif constructWebsocketConnectionOrigin , getWebsocketConnectionOrigin , #if ENABLE_OVERLOADING websocketConnectionOrigin , #endif -- ** protocol #attr:protocol# {- | The chosen protocol, or 'Nothing' if a protocol was not agreed upon. /Since: 2.50/ -} #if ENABLE_OVERLOADING WebsocketConnectionProtocolPropertyInfo , #endif constructWebsocketConnectionProtocol , getWebsocketConnectionProtocol , #if ENABLE_OVERLOADING websocketConnectionProtocol , #endif -- ** state #attr:state# {- | The current state of the WebSocket. /Since: 2.50/ -} #if ENABLE_OVERLOADING WebsocketConnectionStatePropertyInfo , #endif getWebsocketConnectionState , #if ENABLE_OVERLOADING websocketConnectionState , #endif -- ** uri #attr:uri# {- | The URI of the WebSocket. For servers this represents the address of the WebSocket, and for clients it is the address connected to. /Since: 2.50/ -} #if ENABLE_OVERLOADING WebsocketConnectionUriPropertyInfo , #endif constructWebsocketConnectionUri , getWebsocketConnectionUri , #if ENABLE_OVERLOADING websocketConnectionUri , #endif -- * Signals -- ** closed #signal:closed# C_WebsocketConnectionClosedCallback , WebsocketConnectionClosedCallback , #if ENABLE_OVERLOADING WebsocketConnectionClosedSignalInfo , #endif afterWebsocketConnectionClosed , genClosure_WebsocketConnectionClosed , mk_WebsocketConnectionClosedCallback , noWebsocketConnectionClosedCallback , onWebsocketConnectionClosed , wrap_WebsocketConnectionClosedCallback , -- ** closing #signal:closing# C_WebsocketConnectionClosingCallback , WebsocketConnectionClosingCallback , #if ENABLE_OVERLOADING WebsocketConnectionClosingSignalInfo , #endif afterWebsocketConnectionClosing , genClosure_WebsocketConnectionClosing , mk_WebsocketConnectionClosingCallback , noWebsocketConnectionClosingCallback , onWebsocketConnectionClosing , wrap_WebsocketConnectionClosingCallback , -- ** error #signal:error# C_WebsocketConnectionErrorCallback , WebsocketConnectionErrorCallback , #if ENABLE_OVERLOADING WebsocketConnectionErrorSignalInfo , #endif afterWebsocketConnectionError , genClosure_WebsocketConnectionError , mk_WebsocketConnectionErrorCallback , noWebsocketConnectionErrorCallback , onWebsocketConnectionError , wrap_WebsocketConnectionErrorCallback , -- ** message #signal:message# C_WebsocketConnectionMessageCallback , WebsocketConnectionMessageCallback , #if ENABLE_OVERLOADING WebsocketConnectionMessageSignalInfo , #endif afterWebsocketConnectionMessage , genClosure_WebsocketConnectionMessage , mk_WebsocketConnectionMessageCallback , noWebsocketConnectionMessageCallback , onWebsocketConnectionMessage , wrap_WebsocketConnectionMessageCallback , -- ** pong #signal:pong# C_WebsocketConnectionPongCallback , WebsocketConnectionPongCallback , #if ENABLE_OVERLOADING WebsocketConnectionPongSignalInfo , #endif afterWebsocketConnectionPong , genClosure_WebsocketConnectionPong , mk_WebsocketConnectionPongCallback , noWebsocketConnectionPongCallback , onWebsocketConnectionPong , wrap_WebsocketConnectionPongCallback , ) where import Data.GI.Base.ShortPrelude import qualified Data.GI.Base.ShortPrelude as SP import qualified Data.GI.Base.Overloading as O import qualified Prelude as P import qualified Data.GI.Base.Attributes as GI.Attributes import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr import qualified Data.GI.Base.GClosure as B.GClosure import qualified Data.GI.Base.GError as B.GError import qualified Data.GI.Base.GVariant as B.GVariant import qualified Data.GI.Base.GValue as B.GValue import qualified Data.GI.Base.GParamSpec as B.GParamSpec import qualified Data.GI.Base.CallStack as B.CallStack import qualified Data.GI.Base.Properties as B.Properties import qualified Data.Text as T import qualified Data.ByteString.Char8 as B import qualified Data.Map as Map import qualified Foreign.Ptr as FP import qualified GHC.OverloadedLabels as OL import qualified GI.GLib.Structs.Bytes as GLib.Bytes import qualified GI.GObject.Objects.Object as GObject.Object import qualified GI.Gio.Objects.IOStream as Gio.IOStream import {-# SOURCE #-} qualified GI.Soup.Enums as Soup.Enums import {-# SOURCE #-} qualified GI.Soup.Structs.URI as Soup.URI -- | Memory-managed wrapper type. newtype WebsocketConnection = WebsocketConnection (ManagedPtr WebsocketConnection) foreign import ccall "soup_websocket_connection_get_type" c_soup_websocket_connection_get_type :: IO GType instance GObject WebsocketConnection where gobjectType = c_soup_websocket_connection_get_type -- | Type class for types which can be safely cast to `WebsocketConnection`, for instance with `toWebsocketConnection`. class (GObject o, O.IsDescendantOf WebsocketConnection o) => IsWebsocketConnection o instance (GObject o, O.IsDescendantOf WebsocketConnection o) => IsWebsocketConnection o instance O.HasParentTypes WebsocketConnection type instance O.ParentTypes WebsocketConnection = '[GObject.Object.Object] -- | Cast to `WebsocketConnection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toWebsocketConnection :: (MonadIO m, IsWebsocketConnection o) => o -> m WebsocketConnection toWebsocketConnection = liftIO . unsafeCastTo WebsocketConnection -- | A convenience alias for `Nothing` :: `Maybe` `WebsocketConnection`. noWebsocketConnection :: Maybe WebsocketConnection noWebsocketConnection = Nothing #if ENABLE_OVERLOADING type family ResolveWebsocketConnectionMethod (t :: Symbol) (o :: *) :: * where ResolveWebsocketConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveWebsocketConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveWebsocketConnectionMethod "close" o = WebsocketConnectionCloseMethodInfo ResolveWebsocketConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveWebsocketConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveWebsocketConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveWebsocketConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveWebsocketConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveWebsocketConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveWebsocketConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveWebsocketConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveWebsocketConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveWebsocketConnectionMethod "sendBinary" o = WebsocketConnectionSendBinaryMethodInfo ResolveWebsocketConnectionMethod "sendText" o = WebsocketConnectionSendTextMethodInfo ResolveWebsocketConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveWebsocketConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveWebsocketConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveWebsocketConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveWebsocketConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveWebsocketConnectionMethod "getCloseCode" o = WebsocketConnectionGetCloseCodeMethodInfo ResolveWebsocketConnectionMethod "getCloseData" o = WebsocketConnectionGetCloseDataMethodInfo ResolveWebsocketConnectionMethod "getConnectionType" o = WebsocketConnectionGetConnectionTypeMethodInfo ResolveWebsocketConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveWebsocketConnectionMethod "getIoStream" o = WebsocketConnectionGetIoStreamMethodInfo ResolveWebsocketConnectionMethod "getKeepaliveInterval" o = WebsocketConnectionGetKeepaliveIntervalMethodInfo ResolveWebsocketConnectionMethod "getMaxIncomingPayloadSize" o = WebsocketConnectionGetMaxIncomingPayloadSizeMethodInfo ResolveWebsocketConnectionMethod "getOrigin" o = WebsocketConnectionGetOriginMethodInfo ResolveWebsocketConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveWebsocketConnectionMethod "getProtocol" o = WebsocketConnectionGetProtocolMethodInfo ResolveWebsocketConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveWebsocketConnectionMethod "getState" o = WebsocketConnectionGetStateMethodInfo ResolveWebsocketConnectionMethod "getUri" o = WebsocketConnectionGetUriMethodInfo ResolveWebsocketConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveWebsocketConnectionMethod "setKeepaliveInterval" o = WebsocketConnectionSetKeepaliveIntervalMethodInfo ResolveWebsocketConnectionMethod "setMaxIncomingPayloadSize" o = WebsocketConnectionSetMaxIncomingPayloadSizeMethodInfo ResolveWebsocketConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveWebsocketConnectionMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveWebsocketConnectionMethod t WebsocketConnection, O.MethodInfo info WebsocketConnection p) => OL.IsLabel t (WebsocketConnection -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- signal WebsocketConnection::closed {- | Emitted when the connection has completely closed, either due to an orderly close from the peer, one initiated via 'GI.Soup.Objects.WebsocketConnection.websocketConnectionClose' or a fatal error condition that caused a close. This signal will be emitted once. /Since: 2.50/ -} type WebsocketConnectionClosedCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebsocketConnectionClosedCallback`@. noWebsocketConnectionClosedCallback :: Maybe WebsocketConnectionClosedCallback noWebsocketConnectionClosedCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebsocketConnectionClosedCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebsocketConnectionClosedCallback`. foreign import ccall "wrapper" mk_WebsocketConnectionClosedCallback :: C_WebsocketConnectionClosedCallback -> IO (FunPtr C_WebsocketConnectionClosedCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebsocketConnectionClosed :: MonadIO m => WebsocketConnectionClosedCallback -> m (GClosure C_WebsocketConnectionClosedCallback) genClosure_WebsocketConnectionClosed cb = liftIO $ do let cb' = wrap_WebsocketConnectionClosedCallback cb mk_WebsocketConnectionClosedCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebsocketConnectionClosedCallback` into a `C_WebsocketConnectionClosedCallback`. wrap_WebsocketConnectionClosedCallback :: WebsocketConnectionClosedCallback -> C_WebsocketConnectionClosedCallback wrap_WebsocketConnectionClosedCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@closed@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' websocketConnection #closed callback @ -} onWebsocketConnectionClosed :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionClosedCallback -> m SignalHandlerId onWebsocketConnectionClosed obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionClosedCallback cb cb'' <- mk_WebsocketConnectionClosedCallback cb' connectSignalFunPtr obj "closed" cb'' SignalConnectBefore {- | Connect a signal handler for the “@closed@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' websocketConnection #closed callback @ -} afterWebsocketConnectionClosed :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionClosedCallback -> m SignalHandlerId afterWebsocketConnectionClosed obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionClosedCallback cb cb'' <- mk_WebsocketConnectionClosedCallback cb' connectSignalFunPtr obj "closed" cb'' SignalConnectAfter -- signal WebsocketConnection::closing {- | This signal will be emitted during an orderly close. /Since: 2.50/ -} type WebsocketConnectionClosingCallback = IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebsocketConnectionClosingCallback`@. noWebsocketConnectionClosingCallback :: Maybe WebsocketConnectionClosingCallback noWebsocketConnectionClosingCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebsocketConnectionClosingCallback = Ptr () -> -- object Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebsocketConnectionClosingCallback`. foreign import ccall "wrapper" mk_WebsocketConnectionClosingCallback :: C_WebsocketConnectionClosingCallback -> IO (FunPtr C_WebsocketConnectionClosingCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebsocketConnectionClosing :: MonadIO m => WebsocketConnectionClosingCallback -> m (GClosure C_WebsocketConnectionClosingCallback) genClosure_WebsocketConnectionClosing cb = liftIO $ do let cb' = wrap_WebsocketConnectionClosingCallback cb mk_WebsocketConnectionClosingCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebsocketConnectionClosingCallback` into a `C_WebsocketConnectionClosingCallback`. wrap_WebsocketConnectionClosingCallback :: WebsocketConnectionClosingCallback -> C_WebsocketConnectionClosingCallback wrap_WebsocketConnectionClosingCallback _cb _ _ = do _cb {- | Connect a signal handler for the “@closing@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' websocketConnection #closing callback @ -} onWebsocketConnectionClosing :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionClosingCallback -> m SignalHandlerId onWebsocketConnectionClosing obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionClosingCallback cb cb'' <- mk_WebsocketConnectionClosingCallback cb' connectSignalFunPtr obj "closing" cb'' SignalConnectBefore {- | Connect a signal handler for the “@closing@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' websocketConnection #closing callback @ -} afterWebsocketConnectionClosing :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionClosingCallback -> m SignalHandlerId afterWebsocketConnectionClosing obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionClosingCallback cb cb'' <- mk_WebsocketConnectionClosingCallback cb' connectSignalFunPtr obj "closing" cb'' SignalConnectAfter -- signal WebsocketConnection::error {- | Emitted when an error occurred on the WebSocket. This may be fired multiple times. Fatal errors will be followed by the 'GI.Soup.Objects.WebsocketConnection.WebsocketConnection'::@/closed/@ signal being emitted. /Since: 2.50/ -} type WebsocketConnectionErrorCallback = GError {- ^ /@error@/: the error that occured -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebsocketConnectionErrorCallback`@. noWebsocketConnectionErrorCallback :: Maybe WebsocketConnectionErrorCallback noWebsocketConnectionErrorCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebsocketConnectionErrorCallback = Ptr () -> -- object Ptr GError -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebsocketConnectionErrorCallback`. foreign import ccall "wrapper" mk_WebsocketConnectionErrorCallback :: C_WebsocketConnectionErrorCallback -> IO (FunPtr C_WebsocketConnectionErrorCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebsocketConnectionError :: MonadIO m => WebsocketConnectionErrorCallback -> m (GClosure C_WebsocketConnectionErrorCallback) genClosure_WebsocketConnectionError cb = liftIO $ do let cb' = wrap_WebsocketConnectionErrorCallback cb mk_WebsocketConnectionErrorCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebsocketConnectionErrorCallback` into a `C_WebsocketConnectionErrorCallback`. wrap_WebsocketConnectionErrorCallback :: WebsocketConnectionErrorCallback -> C_WebsocketConnectionErrorCallback wrap_WebsocketConnectionErrorCallback _cb _ error_ _ = do error_' <- (newBoxed GError) error_ _cb error_' {- | Connect a signal handler for the “@error@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' websocketConnection #error callback @ -} onWebsocketConnectionError :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionErrorCallback -> m SignalHandlerId onWebsocketConnectionError obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionErrorCallback cb cb'' <- mk_WebsocketConnectionErrorCallback cb' connectSignalFunPtr obj "error" cb'' SignalConnectBefore {- | Connect a signal handler for the “@error@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' websocketConnection #error callback @ -} afterWebsocketConnectionError :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionErrorCallback -> m SignalHandlerId afterWebsocketConnectionError obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionErrorCallback cb cb'' <- mk_WebsocketConnectionErrorCallback cb' connectSignalFunPtr obj "error" cb'' SignalConnectAfter -- signal WebsocketConnection::message {- | Emitted when we receive a message from the peer. As a convenience, the /@message@/ data will always be NUL-terminated, but the NUL byte will not be included in the length count. /Since: 2.50/ -} type WebsocketConnectionMessageCallback = Int32 {- ^ /@type@/: the type of message contents -} -> GLib.Bytes.Bytes {- ^ /@message@/: the message data -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebsocketConnectionMessageCallback`@. noWebsocketConnectionMessageCallback :: Maybe WebsocketConnectionMessageCallback noWebsocketConnectionMessageCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebsocketConnectionMessageCallback = Ptr () -> -- object Int32 -> Ptr GLib.Bytes.Bytes -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebsocketConnectionMessageCallback`. foreign import ccall "wrapper" mk_WebsocketConnectionMessageCallback :: C_WebsocketConnectionMessageCallback -> IO (FunPtr C_WebsocketConnectionMessageCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebsocketConnectionMessage :: MonadIO m => WebsocketConnectionMessageCallback -> m (GClosure C_WebsocketConnectionMessageCallback) genClosure_WebsocketConnectionMessage cb = liftIO $ do let cb' = wrap_WebsocketConnectionMessageCallback cb mk_WebsocketConnectionMessageCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebsocketConnectionMessageCallback` into a `C_WebsocketConnectionMessageCallback`. wrap_WebsocketConnectionMessageCallback :: WebsocketConnectionMessageCallback -> C_WebsocketConnectionMessageCallback wrap_WebsocketConnectionMessageCallback _cb _ type_ message _ = do B.ManagedPtr.withTransient GLib.Bytes.Bytes message $ \message' -> do _cb type_ message' {- | Connect a signal handler for the “@message@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' websocketConnection #message callback @ -} onWebsocketConnectionMessage :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionMessageCallback -> m SignalHandlerId onWebsocketConnectionMessage obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionMessageCallback cb cb'' <- mk_WebsocketConnectionMessageCallback cb' connectSignalFunPtr obj "message" cb'' SignalConnectBefore {- | Connect a signal handler for the “@message@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' websocketConnection #message callback @ -} afterWebsocketConnectionMessage :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionMessageCallback -> m SignalHandlerId afterWebsocketConnectionMessage obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionMessageCallback cb cb'' <- mk_WebsocketConnectionMessageCallback cb' connectSignalFunPtr obj "message" cb'' SignalConnectAfter -- signal WebsocketConnection::pong {- | Emitted when we receive a Pong frame (solicited or unsolicited) from the peer. As a convenience, the /@message@/ data will always be NUL-terminated, but the NUL byte will not be included in the length count. /Since: 2.60/ -} type WebsocketConnectionPongCallback = GLib.Bytes.Bytes {- ^ /@message@/: the application data (if any) -} -> IO () -- | A convenience synonym for @`Nothing` :: `Maybe` `WebsocketConnectionPongCallback`@. noWebsocketConnectionPongCallback :: Maybe WebsocketConnectionPongCallback noWebsocketConnectionPongCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_WebsocketConnectionPongCallback = Ptr () -> -- object Ptr GLib.Bytes.Bytes -> Ptr () -> -- user_data IO () -- | Generate a function pointer callable from C code, from a `C_WebsocketConnectionPongCallback`. foreign import ccall "wrapper" mk_WebsocketConnectionPongCallback :: C_WebsocketConnectionPongCallback -> IO (FunPtr C_WebsocketConnectionPongCallback) -- | Wrap the callback into a `GClosure`. genClosure_WebsocketConnectionPong :: MonadIO m => WebsocketConnectionPongCallback -> m (GClosure C_WebsocketConnectionPongCallback) genClosure_WebsocketConnectionPong cb = liftIO $ do let cb' = wrap_WebsocketConnectionPongCallback cb mk_WebsocketConnectionPongCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `WebsocketConnectionPongCallback` into a `C_WebsocketConnectionPongCallback`. wrap_WebsocketConnectionPongCallback :: WebsocketConnectionPongCallback -> C_WebsocketConnectionPongCallback wrap_WebsocketConnectionPongCallback _cb _ message _ = do B.ManagedPtr.withTransient GLib.Bytes.Bytes message $ \message' -> do _cb message' {- | Connect a signal handler for the “@pong@” signal, to be run before the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.on' websocketConnection #pong callback @ -} onWebsocketConnectionPong :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionPongCallback -> m SignalHandlerId onWebsocketConnectionPong obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionPongCallback cb cb'' <- mk_WebsocketConnectionPongCallback cb' connectSignalFunPtr obj "pong" cb'' SignalConnectBefore {- | Connect a signal handler for the “@pong@” signal, to be run after the default handler. When is enabled, this is equivalent to @ 'Data.GI.Base.Signals.after' websocketConnection #pong callback @ -} afterWebsocketConnectionPong :: (IsWebsocketConnection a, MonadIO m) => a -> WebsocketConnectionPongCallback -> m SignalHandlerId afterWebsocketConnectionPong obj cb = liftIO $ do let cb' = wrap_WebsocketConnectionPongCallback cb cb'' <- mk_WebsocketConnectionPongCallback cb' connectSignalFunPtr obj "pong" cb'' SignalConnectAfter -- VVV Prop "connection-type" -- Type: TInterface (Name {namespace = "Soup", name = "WebsocketConnectionType"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@connection-type@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' websocketConnection #connectionType @ -} getWebsocketConnectionConnectionType :: (MonadIO m, IsWebsocketConnection o) => o -> m Soup.Enums.WebsocketConnectionType getWebsocketConnectionConnectionType obj = liftIO $ B.Properties.getObjectPropertyEnum obj "connection-type" {- | Construct a `GValueConstruct` with valid value for the “@connection-type@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructWebsocketConnectionConnectionType :: (IsWebsocketConnection o) => Soup.Enums.WebsocketConnectionType -> IO (GValueConstruct o) constructWebsocketConnectionConnectionType val = B.Properties.constructObjectPropertyEnum "connection-type" val #if ENABLE_OVERLOADING data WebsocketConnectionConnectionTypePropertyInfo instance AttrInfo WebsocketConnectionConnectionTypePropertyInfo where type AttrAllowedOps WebsocketConnectionConnectionTypePropertyInfo = '[ 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint WebsocketConnectionConnectionTypePropertyInfo = (~) Soup.Enums.WebsocketConnectionType type AttrBaseTypeConstraint WebsocketConnectionConnectionTypePropertyInfo = IsWebsocketConnection type AttrGetType WebsocketConnectionConnectionTypePropertyInfo = Soup.Enums.WebsocketConnectionType type AttrLabel WebsocketConnectionConnectionTypePropertyInfo = "connection-type" type AttrOrigin WebsocketConnectionConnectionTypePropertyInfo = WebsocketConnection attrGet _ = getWebsocketConnectionConnectionType attrSet _ = undefined attrConstruct _ = constructWebsocketConnectionConnectionType attrClear _ = undefined #endif -- VVV Prop "io-stream" -- Type: TInterface (Name {namespace = "Gio", name = "IOStream"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@io-stream@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' websocketConnection #ioStream @ -} getWebsocketConnectionIoStream :: (MonadIO m, IsWebsocketConnection o) => o -> m Gio.IOStream.IOStream getWebsocketConnectionIoStream obj = liftIO $ checkUnexpectedNothing "getWebsocketConnectionIoStream" $ B.Properties.getObjectPropertyObject obj "io-stream" Gio.IOStream.IOStream {- | Construct a `GValueConstruct` with valid value for the “@io-stream@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructWebsocketConnectionIoStream :: (IsWebsocketConnection o, Gio.IOStream.IsIOStream a) => a -> IO (GValueConstruct o) constructWebsocketConnectionIoStream val = B.Properties.constructObjectPropertyObject "io-stream" (Just val) #if ENABLE_OVERLOADING data WebsocketConnectionIoStreamPropertyInfo instance AttrInfo WebsocketConnectionIoStreamPropertyInfo where type AttrAllowedOps WebsocketConnectionIoStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint WebsocketConnectionIoStreamPropertyInfo = Gio.IOStream.IsIOStream type AttrBaseTypeConstraint WebsocketConnectionIoStreamPropertyInfo = IsWebsocketConnection type AttrGetType WebsocketConnectionIoStreamPropertyInfo = Gio.IOStream.IOStream type AttrLabel WebsocketConnectionIoStreamPropertyInfo = "io-stream" type AttrOrigin WebsocketConnectionIoStreamPropertyInfo = WebsocketConnection attrGet _ = getWebsocketConnectionIoStream attrSet _ = undefined attrConstruct _ = constructWebsocketConnectionIoStream attrClear _ = undefined #endif -- VVV Prop "keepalive-interval" -- Type: TBasicType TUInt -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Just False,Just False) {- | Get the value of the “@keepalive-interval@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' websocketConnection #keepaliveInterval @ -} getWebsocketConnectionKeepaliveInterval :: (MonadIO m, IsWebsocketConnection o) => o -> m Word32 getWebsocketConnectionKeepaliveInterval obj = liftIO $ B.Properties.getObjectPropertyUInt32 obj "keepalive-interval" {- | Set the value of the “@keepalive-interval@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' websocketConnection [ #keepaliveInterval 'Data.GI.Base.Attributes.:=' value ] @ -} setWebsocketConnectionKeepaliveInterval :: (MonadIO m, IsWebsocketConnection o) => o -> Word32 -> m () setWebsocketConnectionKeepaliveInterval obj val = liftIO $ B.Properties.setObjectPropertyUInt32 obj "keepalive-interval" val {- | Construct a `GValueConstruct` with valid value for the “@keepalive-interval@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructWebsocketConnectionKeepaliveInterval :: (IsWebsocketConnection o) => Word32 -> IO (GValueConstruct o) constructWebsocketConnectionKeepaliveInterval val = B.Properties.constructObjectPropertyUInt32 "keepalive-interval" val #if ENABLE_OVERLOADING data WebsocketConnectionKeepaliveIntervalPropertyInfo instance AttrInfo WebsocketConnectionKeepaliveIntervalPropertyInfo where type AttrAllowedOps WebsocketConnectionKeepaliveIntervalPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint WebsocketConnectionKeepaliveIntervalPropertyInfo = (~) Word32 type AttrBaseTypeConstraint WebsocketConnectionKeepaliveIntervalPropertyInfo = IsWebsocketConnection type AttrGetType WebsocketConnectionKeepaliveIntervalPropertyInfo = Word32 type AttrLabel WebsocketConnectionKeepaliveIntervalPropertyInfo = "keepalive-interval" type AttrOrigin WebsocketConnectionKeepaliveIntervalPropertyInfo = WebsocketConnection attrGet _ = getWebsocketConnectionKeepaliveInterval attrSet _ = setWebsocketConnectionKeepaliveInterval attrConstruct _ = constructWebsocketConnectionKeepaliveInterval attrClear _ = undefined #endif -- VVV Prop "max-incoming-payload-size" -- Type: TBasicType TUInt64 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Just False,Just False) {- | Get the value of the “@max-incoming-payload-size@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' websocketConnection #maxIncomingPayloadSize @ -} getWebsocketConnectionMaxIncomingPayloadSize :: (MonadIO m, IsWebsocketConnection o) => o -> m Word64 getWebsocketConnectionMaxIncomingPayloadSize obj = liftIO $ B.Properties.getObjectPropertyUInt64 obj "max-incoming-payload-size" {- | Set the value of the “@max-incoming-payload-size@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' websocketConnection [ #maxIncomingPayloadSize 'Data.GI.Base.Attributes.:=' value ] @ -} setWebsocketConnectionMaxIncomingPayloadSize :: (MonadIO m, IsWebsocketConnection o) => o -> Word64 -> m () setWebsocketConnectionMaxIncomingPayloadSize obj val = liftIO $ B.Properties.setObjectPropertyUInt64 obj "max-incoming-payload-size" val {- | Construct a `GValueConstruct` with valid value for the “@max-incoming-payload-size@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructWebsocketConnectionMaxIncomingPayloadSize :: (IsWebsocketConnection o) => Word64 -> IO (GValueConstruct o) constructWebsocketConnectionMaxIncomingPayloadSize val = B.Properties.constructObjectPropertyUInt64 "max-incoming-payload-size" val #if ENABLE_OVERLOADING data WebsocketConnectionMaxIncomingPayloadSizePropertyInfo instance AttrInfo WebsocketConnectionMaxIncomingPayloadSizePropertyInfo where type AttrAllowedOps WebsocketConnectionMaxIncomingPayloadSizePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint WebsocketConnectionMaxIncomingPayloadSizePropertyInfo = (~) Word64 type AttrBaseTypeConstraint WebsocketConnectionMaxIncomingPayloadSizePropertyInfo = IsWebsocketConnection type AttrGetType WebsocketConnectionMaxIncomingPayloadSizePropertyInfo = Word64 type AttrLabel WebsocketConnectionMaxIncomingPayloadSizePropertyInfo = "max-incoming-payload-size" type AttrOrigin WebsocketConnectionMaxIncomingPayloadSizePropertyInfo = WebsocketConnection attrGet _ = getWebsocketConnectionMaxIncomingPayloadSize attrSet _ = setWebsocketConnectionMaxIncomingPayloadSize attrConstruct _ = constructWebsocketConnectionMaxIncomingPayloadSize attrClear _ = undefined #endif -- VVV Prop "origin" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just True,Nothing) {- | Get the value of the “@origin@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' websocketConnection #origin @ -} getWebsocketConnectionOrigin :: (MonadIO m, IsWebsocketConnection o) => o -> m (Maybe T.Text) getWebsocketConnectionOrigin obj = liftIO $ B.Properties.getObjectPropertyString obj "origin" {- | Construct a `GValueConstruct` with valid value for the “@origin@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructWebsocketConnectionOrigin :: (IsWebsocketConnection o) => T.Text -> IO (GValueConstruct o) constructWebsocketConnectionOrigin val = B.Properties.constructObjectPropertyString "origin" (Just val) #if ENABLE_OVERLOADING data WebsocketConnectionOriginPropertyInfo instance AttrInfo WebsocketConnectionOriginPropertyInfo where type AttrAllowedOps WebsocketConnectionOriginPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint WebsocketConnectionOriginPropertyInfo = (~) T.Text type AttrBaseTypeConstraint WebsocketConnectionOriginPropertyInfo = IsWebsocketConnection type AttrGetType WebsocketConnectionOriginPropertyInfo = (Maybe T.Text) type AttrLabel WebsocketConnectionOriginPropertyInfo = "origin" type AttrOrigin WebsocketConnectionOriginPropertyInfo = WebsocketConnection attrGet _ = getWebsocketConnectionOrigin attrSet _ = undefined attrConstruct _ = constructWebsocketConnectionOrigin attrClear _ = undefined #endif -- VVV Prop "protocol" -- Type: TBasicType TUTF8 -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just True,Nothing) {- | Get the value of the “@protocol@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' websocketConnection #protocol @ -} getWebsocketConnectionProtocol :: (MonadIO m, IsWebsocketConnection o) => o -> m (Maybe T.Text) getWebsocketConnectionProtocol obj = liftIO $ B.Properties.getObjectPropertyString obj "protocol" {- | Construct a `GValueConstruct` with valid value for the “@protocol@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructWebsocketConnectionProtocol :: (IsWebsocketConnection o) => T.Text -> IO (GValueConstruct o) constructWebsocketConnectionProtocol val = B.Properties.constructObjectPropertyString "protocol" (Just val) #if ENABLE_OVERLOADING data WebsocketConnectionProtocolPropertyInfo instance AttrInfo WebsocketConnectionProtocolPropertyInfo where type AttrAllowedOps WebsocketConnectionProtocolPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint WebsocketConnectionProtocolPropertyInfo = (~) T.Text type AttrBaseTypeConstraint WebsocketConnectionProtocolPropertyInfo = IsWebsocketConnection type AttrGetType WebsocketConnectionProtocolPropertyInfo = (Maybe T.Text) type AttrLabel WebsocketConnectionProtocolPropertyInfo = "protocol" type AttrOrigin WebsocketConnectionProtocolPropertyInfo = WebsocketConnection attrGet _ = getWebsocketConnectionProtocol attrSet _ = undefined attrConstruct _ = constructWebsocketConnectionProtocol attrClear _ = undefined #endif -- VVV Prop "state" -- Type: TInterface (Name {namespace = "Soup", name = "WebsocketState"}) -- Flags: [PropertyReadable] -- Nullable: (Just False,Nothing) {- | Get the value of the “@state@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' websocketConnection #state @ -} getWebsocketConnectionState :: (MonadIO m, IsWebsocketConnection o) => o -> m Soup.Enums.WebsocketState getWebsocketConnectionState obj = liftIO $ B.Properties.getObjectPropertyEnum obj "state" #if ENABLE_OVERLOADING data WebsocketConnectionStatePropertyInfo instance AttrInfo WebsocketConnectionStatePropertyInfo where type AttrAllowedOps WebsocketConnectionStatePropertyInfo = '[ 'AttrGet] type AttrSetTypeConstraint WebsocketConnectionStatePropertyInfo = (~) () type AttrBaseTypeConstraint WebsocketConnectionStatePropertyInfo = IsWebsocketConnection type AttrGetType WebsocketConnectionStatePropertyInfo = Soup.Enums.WebsocketState type AttrLabel WebsocketConnectionStatePropertyInfo = "state" type AttrOrigin WebsocketConnectionStatePropertyInfo = WebsocketConnection attrGet _ = getWebsocketConnectionState attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "uri" -- Type: TInterface (Name {namespace = "Soup", name = "URI"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@uri@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' websocketConnection #uri @ -} getWebsocketConnectionUri :: (MonadIO m, IsWebsocketConnection o) => o -> m Soup.URI.URI getWebsocketConnectionUri obj = liftIO $ checkUnexpectedNothing "getWebsocketConnectionUri" $ B.Properties.getObjectPropertyBoxed obj "uri" Soup.URI.URI {- | Construct a `GValueConstruct` with valid value for the “@uri@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructWebsocketConnectionUri :: (IsWebsocketConnection o) => Soup.URI.URI -> IO (GValueConstruct o) constructWebsocketConnectionUri val = B.Properties.constructObjectPropertyBoxed "uri" (Just val) #if ENABLE_OVERLOADING data WebsocketConnectionUriPropertyInfo instance AttrInfo WebsocketConnectionUriPropertyInfo where type AttrAllowedOps WebsocketConnectionUriPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint WebsocketConnectionUriPropertyInfo = (~) Soup.URI.URI type AttrBaseTypeConstraint WebsocketConnectionUriPropertyInfo = IsWebsocketConnection type AttrGetType WebsocketConnectionUriPropertyInfo = Soup.URI.URI type AttrLabel WebsocketConnectionUriPropertyInfo = "uri" type AttrOrigin WebsocketConnectionUriPropertyInfo = WebsocketConnection attrGet _ = getWebsocketConnectionUri attrSet _ = undefined attrConstruct _ = constructWebsocketConnectionUri attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList WebsocketConnection type instance O.AttributeList WebsocketConnection = WebsocketConnectionAttributeList type WebsocketConnectionAttributeList = ('[ '("connectionType", WebsocketConnectionConnectionTypePropertyInfo), '("ioStream", WebsocketConnectionIoStreamPropertyInfo), '("keepaliveInterval", WebsocketConnectionKeepaliveIntervalPropertyInfo), '("maxIncomingPayloadSize", WebsocketConnectionMaxIncomingPayloadSizePropertyInfo), '("origin", WebsocketConnectionOriginPropertyInfo), '("protocol", WebsocketConnectionProtocolPropertyInfo), '("state", WebsocketConnectionStatePropertyInfo), '("uri", WebsocketConnectionUriPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING websocketConnectionConnectionType :: AttrLabelProxy "connectionType" websocketConnectionConnectionType = AttrLabelProxy websocketConnectionIoStream :: AttrLabelProxy "ioStream" websocketConnectionIoStream = AttrLabelProxy websocketConnectionKeepaliveInterval :: AttrLabelProxy "keepaliveInterval" websocketConnectionKeepaliveInterval = AttrLabelProxy websocketConnectionMaxIncomingPayloadSize :: AttrLabelProxy "maxIncomingPayloadSize" websocketConnectionMaxIncomingPayloadSize = AttrLabelProxy websocketConnectionOrigin :: AttrLabelProxy "origin" websocketConnectionOrigin = AttrLabelProxy websocketConnectionProtocol :: AttrLabelProxy "protocol" websocketConnectionProtocol = AttrLabelProxy websocketConnectionState :: AttrLabelProxy "state" websocketConnectionState = AttrLabelProxy websocketConnectionUri :: AttrLabelProxy "uri" websocketConnectionUri = AttrLabelProxy #endif #if ENABLE_OVERLOADING data WebsocketConnectionClosedSignalInfo instance SignalInfo WebsocketConnectionClosedSignalInfo where type HaskellCallbackType WebsocketConnectionClosedSignalInfo = WebsocketConnectionClosedCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebsocketConnectionClosedCallback cb cb'' <- mk_WebsocketConnectionClosedCallback cb' connectSignalFunPtr obj "closed" cb'' connectMode data WebsocketConnectionClosingSignalInfo instance SignalInfo WebsocketConnectionClosingSignalInfo where type HaskellCallbackType WebsocketConnectionClosingSignalInfo = WebsocketConnectionClosingCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebsocketConnectionClosingCallback cb cb'' <- mk_WebsocketConnectionClosingCallback cb' connectSignalFunPtr obj "closing" cb'' connectMode data WebsocketConnectionErrorSignalInfo instance SignalInfo WebsocketConnectionErrorSignalInfo where type HaskellCallbackType WebsocketConnectionErrorSignalInfo = WebsocketConnectionErrorCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebsocketConnectionErrorCallback cb cb'' <- mk_WebsocketConnectionErrorCallback cb' connectSignalFunPtr obj "error" cb'' connectMode data WebsocketConnectionMessageSignalInfo instance SignalInfo WebsocketConnectionMessageSignalInfo where type HaskellCallbackType WebsocketConnectionMessageSignalInfo = WebsocketConnectionMessageCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebsocketConnectionMessageCallback cb cb'' <- mk_WebsocketConnectionMessageCallback cb' connectSignalFunPtr obj "message" cb'' connectMode data WebsocketConnectionPongSignalInfo instance SignalInfo WebsocketConnectionPongSignalInfo where type HaskellCallbackType WebsocketConnectionPongSignalInfo = WebsocketConnectionPongCallback connectSignal _ obj cb connectMode = do let cb' = wrap_WebsocketConnectionPongCallback cb cb'' <- mk_WebsocketConnectionPongCallback cb' connectSignalFunPtr obj "pong" cb'' connectMode type instance O.SignalList WebsocketConnection = WebsocketConnectionSignalList type WebsocketConnectionSignalList = ('[ '("closed", WebsocketConnectionClosedSignalInfo), '("closing", WebsocketConnectionClosingSignalInfo), '("error", WebsocketConnectionErrorSignalInfo), '("message", WebsocketConnectionMessageSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo), '("pong", WebsocketConnectionPongSignalInfo)] :: [(Symbol, *)]) #endif -- method WebsocketConnection::new -- method type : Constructor -- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOStream connected to the WebSocket server", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "uri", argType = TInterface (Name {namespace = "Soup", name = "URI"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the URI of the connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnectionType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the type of connection (client/side)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "origin", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the Origin of the client", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the subprotocol in use", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Soup", name = "WebsocketConnection"})) -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_new" soup_websocket_connection_new :: Ptr Gio.IOStream.IOStream -> -- stream : TInterface (Name {namespace = "Gio", name = "IOStream"}) Ptr Soup.URI.URI -> -- uri : TInterface (Name {namespace = "Soup", name = "URI"}) CUInt -> -- type : TInterface (Name {namespace = "Soup", name = "WebsocketConnectionType"}) CString -> -- origin : TBasicType TUTF8 CString -> -- protocol : TBasicType TUTF8 IO (Ptr WebsocketConnection) {- | Creates a 'GI.Soup.Objects.WebsocketConnection.WebsocketConnection' on /@stream@/. This should be called after completing the handshake to begin using the WebSocket protocol. /Since: 2.50/ -} websocketConnectionNew :: (B.CallStack.HasCallStack, MonadIO m, Gio.IOStream.IsIOStream a) => a {- ^ /@stream@/: a 'GI.Gio.Objects.IOStream.IOStream' connected to the WebSocket server -} -> Soup.URI.URI {- ^ /@uri@/: the URI of the connection -} -> Soup.Enums.WebsocketConnectionType {- ^ /@type@/: the type of connection (client\/side) -} -> Maybe (T.Text) {- ^ /@origin@/: the Origin of the client -} -> Maybe (T.Text) {- ^ /@protocol@/: the subprotocol in use -} -> m WebsocketConnection {- ^ __Returns:__ a new 'GI.Soup.Objects.WebsocketConnection.WebsocketConnection' -} websocketConnectionNew stream uri type_ origin protocol = liftIO $ do stream' <- unsafeManagedPtrCastPtr stream uri' <- unsafeManagedPtrGetPtr uri let type_' = (fromIntegral . fromEnum) type_ maybeOrigin <- case origin of Nothing -> return nullPtr Just jOrigin -> do jOrigin' <- textToCString jOrigin return jOrigin' maybeProtocol <- case protocol of Nothing -> return nullPtr Just jProtocol -> do jProtocol' <- textToCString jProtocol return jProtocol' result <- soup_websocket_connection_new stream' uri' type_' maybeOrigin maybeProtocol checkUnexpectedReturnNULL "websocketConnectionNew" result result' <- (wrapObject WebsocketConnection) result touchManagedPtr stream touchManagedPtr uri freeMem maybeOrigin freeMem maybeProtocol return result' #if ENABLE_OVERLOADING #endif -- method WebsocketConnection::close -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "code", argType = TBasicType TUInt16, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "close code", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "close data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_close" soup_websocket_connection_close :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) Word16 -> -- code : TBasicType TUInt16 CString -> -- data : TBasicType TUTF8 IO () {- | Close the connection in an orderly fashion. Note that until the 'GI.Soup.Objects.WebsocketConnection.WebsocketConnection'::@/closed/@ signal fires, the connection is not yet completely closed. The close message is not even sent until the main loop runs. The /@code@/ and /@data@/ are sent to the peer along with the close request. Note that the /@data@/ must be UTF-8 valid. /Since: 2.50/ -} websocketConnectionClose :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> Word16 {- ^ /@code@/: close code -} -> Maybe (T.Text) {- ^ /@data@/: close data -} -> m () websocketConnectionClose self code data_ = liftIO $ do self' <- unsafeManagedPtrCastPtr self maybeData_ <- case data_ of Nothing -> return nullPtr Just jData_ -> do jData_' <- textToCString jData_ return jData_' soup_websocket_connection_close self' code maybeData_ touchManagedPtr self freeMem maybeData_ return () #if ENABLE_OVERLOADING data WebsocketConnectionCloseMethodInfo instance (signature ~ (Word16 -> Maybe (T.Text) -> m ()), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionCloseMethodInfo a signature where overloadedMethod _ = websocketConnectionClose #endif -- method WebsocketConnection::get_close_code -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt16) -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_get_close_code" soup_websocket_connection_get_close_code :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO Word16 {- | Get the close code received from the WebSocket peer. This only becomes valid once the WebSocket is in the 'GI.Soup.Enums.WebsocketStateClosed' state. The value will often be in the 'GI.Soup.Enums.WebsocketCloseCode' enumeration, but may also be an application defined close code. /Since: 2.50/ -} websocketConnectionGetCloseCode :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m Word16 {- ^ __Returns:__ the close code or zero. -} websocketConnectionGetCloseCode self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_close_code self' touchManagedPtr self return result #if ENABLE_OVERLOADING data WebsocketConnectionGetCloseCodeMethodInfo instance (signature ~ (m Word16), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetCloseCodeMethodInfo a signature where overloadedMethod _ = websocketConnectionGetCloseCode #endif -- method WebsocketConnection::get_close_data -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", 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_websocket_connection_get_close_data" soup_websocket_connection_get_close_data :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO CString {- | Get the close data received from the WebSocket peer. This only becomes valid once the WebSocket is in the 'GI.Soup.Enums.WebsocketStateClosed' state. The data may be freed once the main loop is run, so copy it if you need to keep it around. /Since: 2.50/ -} websocketConnectionGetCloseData :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m T.Text {- ^ __Returns:__ the close data or 'Nothing' -} websocketConnectionGetCloseData self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_close_data self' checkUnexpectedReturnNULL "websocketConnectionGetCloseData" result result' <- cstringToText result touchManagedPtr self return result' #if ENABLE_OVERLOADING data WebsocketConnectionGetCloseDataMethodInfo instance (signature ~ (m T.Text), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetCloseDataMethodInfo a signature where overloadedMethod _ = websocketConnectionGetCloseData #endif -- method WebsocketConnection::get_connection_type -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Soup", name = "WebsocketConnectionType"})) -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_get_connection_type" soup_websocket_connection_get_connection_type :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO CUInt {- | Get the connection type (client\/server) of the connection. /Since: 2.50/ -} websocketConnectionGetConnectionType :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m Soup.Enums.WebsocketConnectionType {- ^ __Returns:__ the connection type -} websocketConnectionGetConnectionType self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_connection_type self' let result' = (toEnum . fromIntegral) result touchManagedPtr self return result' #if ENABLE_OVERLOADING data WebsocketConnectionGetConnectionTypeMethodInfo instance (signature ~ (m Soup.Enums.WebsocketConnectionType), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetConnectionTypeMethodInfo a signature where overloadedMethod _ = websocketConnectionGetConnectionType #endif -- method WebsocketConnection::get_io_stream -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", 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_websocket_connection_get_io_stream" soup_websocket_connection_get_io_stream :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO (Ptr Gio.IOStream.IOStream) {- | Get the I\/O stream the WebSocket is communicating over. /Since: 2.50/ -} websocketConnectionGetIoStream :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m Gio.IOStream.IOStream {- ^ __Returns:__ the WebSocket\'s I\/O stream. -} websocketConnectionGetIoStream self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_io_stream self' checkUnexpectedReturnNULL "websocketConnectionGetIoStream" result result' <- (newObject Gio.IOStream.IOStream) result touchManagedPtr self return result' #if ENABLE_OVERLOADING data WebsocketConnectionGetIoStreamMethodInfo instance (signature ~ (m Gio.IOStream.IOStream), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetIoStreamMethodInfo a signature where overloadedMethod _ = websocketConnectionGetIoStream #endif -- method WebsocketConnection::get_keepalive_interval -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", 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_websocket_connection_get_keepalive_interval" soup_websocket_connection_get_keepalive_interval :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO Word32 {- | Gets the keepalive interval in seconds or 0 if disabled. /Since: 2.58/ -} websocketConnectionGetKeepaliveInterval :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m Word32 {- ^ __Returns:__ the keepalive interval. -} websocketConnectionGetKeepaliveInterval self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_keepalive_interval self' touchManagedPtr self return result #if ENABLE_OVERLOADING data WebsocketConnectionGetKeepaliveIntervalMethodInfo instance (signature ~ (m Word32), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetKeepaliveIntervalMethodInfo a signature where overloadedMethod _ = websocketConnectionGetKeepaliveInterval #endif -- method WebsocketConnection::get_max_incoming_payload_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt64) -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_get_max_incoming_payload_size" soup_websocket_connection_get_max_incoming_payload_size :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO Word64 {- | Gets the maximum payload size allowed for incoming packets. /Since: 2.56/ -} websocketConnectionGetMaxIncomingPayloadSize :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m Word64 {- ^ __Returns:__ the maximum payload size. -} websocketConnectionGetMaxIncomingPayloadSize self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_max_incoming_payload_size self' touchManagedPtr self return result #if ENABLE_OVERLOADING data WebsocketConnectionGetMaxIncomingPayloadSizeMethodInfo instance (signature ~ (m Word64), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetMaxIncomingPayloadSizeMethodInfo a signature where overloadedMethod _ = websocketConnectionGetMaxIncomingPayloadSize #endif -- method WebsocketConnection::get_origin -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", 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_websocket_connection_get_origin" soup_websocket_connection_get_origin :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO CString {- | Get the origin of the WebSocket. /Since: 2.50/ -} websocketConnectionGetOrigin :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m (Maybe T.Text) {- ^ __Returns:__ the origin, or 'Nothing' -} websocketConnectionGetOrigin self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_origin self' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr self return maybeResult #if ENABLE_OVERLOADING data WebsocketConnectionGetOriginMethodInfo instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetOriginMethodInfo a signature where overloadedMethod _ = websocketConnectionGetOrigin #endif -- method WebsocketConnection::get_protocol -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", 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_websocket_connection_get_protocol" soup_websocket_connection_get_protocol :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO CString {- | Get the protocol chosen via negotiation with the peer. /Since: 2.50/ -} websocketConnectionGetProtocol :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m (Maybe T.Text) {- ^ __Returns:__ the chosen protocol, or 'Nothing' -} websocketConnectionGetProtocol self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_protocol self' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr self return maybeResult #if ENABLE_OVERLOADING data WebsocketConnectionGetProtocolMethodInfo instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetProtocolMethodInfo a signature where overloadedMethod _ = websocketConnectionGetProtocol #endif -- method WebsocketConnection::get_state -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Soup", name = "WebsocketState"})) -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_get_state" soup_websocket_connection_get_state :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO CUInt {- | Get the current state of the WebSocket. /Since: 2.50/ -} websocketConnectionGetState :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m Soup.Enums.WebsocketState {- ^ __Returns:__ the state -} websocketConnectionGetState self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_state self' let result' = (toEnum . fromIntegral) result touchManagedPtr self return result' #if ENABLE_OVERLOADING data WebsocketConnectionGetStateMethodInfo instance (signature ~ (m Soup.Enums.WebsocketState), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetStateMethodInfo a signature where overloadedMethod _ = websocketConnectionGetState #endif -- method WebsocketConnection::get_uri -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Soup", name = "URI"})) -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_get_uri" soup_websocket_connection_get_uri :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) IO (Ptr Soup.URI.URI) {- | Get the URI of the WebSocket. For servers this represents the address of the WebSocket, and for clients it is the address connected to. /Since: 2.50/ -} websocketConnectionGetUri :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> m Soup.URI.URI {- ^ __Returns:__ the URI -} websocketConnectionGetUri self = liftIO $ do self' <- unsafeManagedPtrCastPtr self result <- soup_websocket_connection_get_uri self' checkUnexpectedReturnNULL "websocketConnectionGetUri" result result' <- (newBoxed Soup.URI.URI) result touchManagedPtr self return result' #if ENABLE_OVERLOADING data WebsocketConnectionGetUriMethodInfo instance (signature ~ (m Soup.URI.URI), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionGetUriMethodInfo a signature where overloadedMethod _ = websocketConnectionGetUri #endif -- method WebsocketConnection::send_binary -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "data", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message contents", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the length of @data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_send_binary" soup_websocket_connection_send_binary :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) Ptr Word8 -> -- data : TCArray False (-1) 2 (TBasicType TUInt8) Word64 -> -- length : TBasicType TUInt64 IO () {- | Send a binary message to the peer. The message is queued to be sent and will be sent when the main loop is run. /Since: 2.50/ -} websocketConnectionSendBinary :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> ByteString {- ^ /@data@/: the message contents -} -> m () websocketConnectionSendBinary self data_ = liftIO $ do let length_ = fromIntegral $ B.length data_ self' <- unsafeManagedPtrCastPtr self data_' <- packByteString data_ soup_websocket_connection_send_binary self' data_' length_ touchManagedPtr self freeMem data_' return () #if ENABLE_OVERLOADING data WebsocketConnectionSendBinaryMethodInfo instance (signature ~ (ByteString -> m ()), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionSendBinaryMethodInfo a signature where overloadedMethod _ = websocketConnectionSendBinary #endif -- method WebsocketConnection::send_text -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "text", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the message contents", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_send_text" soup_websocket_connection_send_text :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) CString -> -- text : TBasicType TUTF8 IO () {- | Send a text (UTF-8) message to the peer. The message is queued to be sent and will be sent when the main loop is run. /Since: 2.50/ -} websocketConnectionSendText :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> T.Text {- ^ /@text@/: the message contents -} -> m () websocketConnectionSendText self text = liftIO $ do self' <- unsafeManagedPtrCastPtr self text' <- textToCString text soup_websocket_connection_send_text self' text' touchManagedPtr self freeMem text' return () #if ENABLE_OVERLOADING data WebsocketConnectionSendTextMethodInfo instance (signature ~ (T.Text -> m ()), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionSendTextMethodInfo a signature where overloadedMethod _ = websocketConnectionSendText #endif -- method WebsocketConnection::set_keepalive_interval -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interval", argType = TBasicType TUInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the interval to send a ping message or 0 to disable it", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_set_keepalive_interval" soup_websocket_connection_set_keepalive_interval :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) Word32 -> -- interval : TBasicType TUInt IO () {- | Sets the interval in seconds on when to send a ping message which will serve as a keepalive message. If set to 0 the keepalive message is disabled. /Since: 2.58/ -} websocketConnectionSetKeepaliveInterval :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> Word32 {- ^ /@interval@/: the interval to send a ping message or 0 to disable it -} -> m () websocketConnectionSetKeepaliveInterval self interval = liftIO $ do self' <- unsafeManagedPtrCastPtr self soup_websocket_connection_set_keepalive_interval self' interval touchManagedPtr self return () #if ENABLE_OVERLOADING data WebsocketConnectionSetKeepaliveIntervalMethodInfo instance (signature ~ (Word32 -> m ()), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionSetKeepaliveIntervalMethodInfo a signature where overloadedMethod _ = websocketConnectionSetKeepaliveInterval #endif -- method WebsocketConnection::set_max_incoming_payload_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "self", argType = TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the WebSocket", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "max_incoming_payload_size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the maximum payload size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "soup_websocket_connection_set_max_incoming_payload_size" soup_websocket_connection_set_max_incoming_payload_size :: Ptr WebsocketConnection -> -- self : TInterface (Name {namespace = "Soup", name = "WebsocketConnection"}) Word64 -> -- max_incoming_payload_size : TBasicType TUInt64 IO () {- | Sets the maximum payload size allowed for incoming packets. It does not limit the outgoing packet size. /Since: 2.56/ -} websocketConnectionSetMaxIncomingPayloadSize :: (B.CallStack.HasCallStack, MonadIO m, IsWebsocketConnection a) => a {- ^ /@self@/: the WebSocket -} -> Word64 {- ^ /@maxIncomingPayloadSize@/: the maximum payload size -} -> m () websocketConnectionSetMaxIncomingPayloadSize self maxIncomingPayloadSize = liftIO $ do self' <- unsafeManagedPtrCastPtr self soup_websocket_connection_set_max_incoming_payload_size self' maxIncomingPayloadSize touchManagedPtr self return () #if ENABLE_OVERLOADING data WebsocketConnectionSetMaxIncomingPayloadSizeMethodInfo instance (signature ~ (Word64 -> m ()), MonadIO m, IsWebsocketConnection a) => O.MethodInfo WebsocketConnectionSetMaxIncomingPayloadSizeMethodInfo a signature where overloadedMethod _ = websocketConnectionSetMaxIncomingPayloadSize #endif