{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 'GI.Gio.Objects.SocketConnection.SocketConnection' is a 'GI.Gio.Objects.IOStream.IOStream' for a connected socket. They can be created either by 'GI.Gio.Objects.SocketClient.SocketClient' when connecting to a host, or by 'GI.Gio.Objects.SocketListener.SocketListener' when accepting a new client. The type of the 'GI.Gio.Objects.SocketConnection.SocketConnection' object returned from these calls depends on the type of the underlying socket that is in use. For instance, for a TCP\/IP connection it will be a 'GI.Gio.Objects.TcpConnection.TcpConnection'. Choosing what type of object to construct is done with the socket connection factory, and it is possible for 3rd parties to register custom socket connection types for specific combination of socket family\/type\/protocol using 'GI.Gio.Objects.SocketConnection.socketConnectionFactoryRegisterType'. To close a 'GI.Gio.Objects.SocketConnection.SocketConnection', use 'GI.Gio.Objects.IOStream.iOStreamClose'. Closing both substreams of the 'GI.Gio.Objects.IOStream.IOStream' separately will not close the underlying 'GI.Gio.Objects.Socket.Socket'. /Since: 2.22/ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.SocketConnection ( -- * Exported types SocketConnection(..) , IsSocketConnection , toSocketConnection , noSocketConnection , -- * Methods -- ** connect #method:connect# #if ENABLE_OVERLOADING SocketConnectionConnectMethodInfo , #endif socketConnectionConnect , -- ** connectAsync #method:connectAsync# #if ENABLE_OVERLOADING SocketConnectionConnectAsyncMethodInfo , #endif socketConnectionConnectAsync , -- ** connectFinish #method:connectFinish# #if ENABLE_OVERLOADING SocketConnectionConnectFinishMethodInfo , #endif socketConnectionConnectFinish , -- ** factoryLookupType #method:factoryLookupType# socketConnectionFactoryLookupType , -- ** factoryRegisterType #method:factoryRegisterType# socketConnectionFactoryRegisterType , -- ** getLocalAddress #method:getLocalAddress# #if ENABLE_OVERLOADING SocketConnectionGetLocalAddressMethodInfo, #endif socketConnectionGetLocalAddress , -- ** getRemoteAddress #method:getRemoteAddress# #if ENABLE_OVERLOADING SocketConnectionGetRemoteAddressMethodInfo, #endif socketConnectionGetRemoteAddress , -- ** getSocket #method:getSocket# #if ENABLE_OVERLOADING SocketConnectionGetSocketMethodInfo , #endif socketConnectionGetSocket , -- ** isConnected #method:isConnected# #if ENABLE_OVERLOADING SocketConnectionIsConnectedMethodInfo , #endif socketConnectionIsConnected , -- * Properties -- ** socket #attr:socket# {- | /No description available in the introspection data./ -} #if ENABLE_OVERLOADING SocketConnectionSocketPropertyInfo , #endif constructSocketConnectionSocket , getSocketConnectionSocket , #if ENABLE_OVERLOADING socketConnectionSocket , #endif ) 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.GObject.Objects.Object as GObject.Object import qualified GI.Gio.Callbacks as Gio.Callbacks import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable import {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream import {-# SOURCE #-} qualified GI.Gio.Objects.Socket as Gio.Socket import {-# SOURCE #-} qualified GI.Gio.Objects.SocketAddress as Gio.SocketAddress -- | Memory-managed wrapper type. newtype SocketConnection = SocketConnection (ManagedPtr SocketConnection) foreign import ccall "g_socket_connection_get_type" c_g_socket_connection_get_type :: IO GType instance GObject SocketConnection where gobjectType = c_g_socket_connection_get_type -- | Type class for types which can be safely cast to `SocketConnection`, for instance with `toSocketConnection`. class (GObject o, O.IsDescendantOf SocketConnection o) => IsSocketConnection o instance (GObject o, O.IsDescendantOf SocketConnection o) => IsSocketConnection o instance O.HasParentTypes SocketConnection type instance O.ParentTypes SocketConnection = '[Gio.IOStream.IOStream, GObject.Object.Object] -- | Cast to `SocketConnection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toSocketConnection :: (MonadIO m, IsSocketConnection o) => o -> m SocketConnection toSocketConnection = liftIO . unsafeCastTo SocketConnection -- | A convenience alias for `Nothing` :: `Maybe` `SocketConnection`. noSocketConnection :: Maybe SocketConnection noSocketConnection = Nothing #if ENABLE_OVERLOADING type family ResolveSocketConnectionMethod (t :: Symbol) (o :: *) :: * where ResolveSocketConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveSocketConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveSocketConnectionMethod "clearPending" o = Gio.IOStream.IOStreamClearPendingMethodInfo ResolveSocketConnectionMethod "close" o = Gio.IOStream.IOStreamCloseMethodInfo ResolveSocketConnectionMethod "closeAsync" o = Gio.IOStream.IOStreamCloseAsyncMethodInfo ResolveSocketConnectionMethod "closeFinish" o = Gio.IOStream.IOStreamCloseFinishMethodInfo ResolveSocketConnectionMethod "connect" o = SocketConnectionConnectMethodInfo ResolveSocketConnectionMethod "connectAsync" o = SocketConnectionConnectAsyncMethodInfo ResolveSocketConnectionMethod "connectFinish" o = SocketConnectionConnectFinishMethodInfo ResolveSocketConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveSocketConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveSocketConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveSocketConnectionMethod "hasPending" o = Gio.IOStream.IOStreamHasPendingMethodInfo ResolveSocketConnectionMethod "isClosed" o = Gio.IOStream.IOStreamIsClosedMethodInfo ResolveSocketConnectionMethod "isConnected" o = SocketConnectionIsConnectedMethodInfo ResolveSocketConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveSocketConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveSocketConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveSocketConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveSocketConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveSocketConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveSocketConnectionMethod "spliceAsync" o = Gio.IOStream.IOStreamSpliceAsyncMethodInfo ResolveSocketConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveSocketConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveSocketConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveSocketConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveSocketConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveSocketConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveSocketConnectionMethod "getInputStream" o = Gio.IOStream.IOStreamGetInputStreamMethodInfo ResolveSocketConnectionMethod "getLocalAddress" o = SocketConnectionGetLocalAddressMethodInfo ResolveSocketConnectionMethod "getOutputStream" o = Gio.IOStream.IOStreamGetOutputStreamMethodInfo ResolveSocketConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveSocketConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveSocketConnectionMethod "getRemoteAddress" o = SocketConnectionGetRemoteAddressMethodInfo ResolveSocketConnectionMethod "getSocket" o = SocketConnectionGetSocketMethodInfo ResolveSocketConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveSocketConnectionMethod "setPending" o = Gio.IOStream.IOStreamSetPendingMethodInfo ResolveSocketConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveSocketConnectionMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveSocketConnectionMethod t SocketConnection, O.MethodInfo info SocketConnection p) => OL.IsLabel t (SocketConnection -> 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 -- VVV Prop "socket" -- Type: TInterface (Name {namespace = "Gio", name = "Socket"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Just False,Nothing) {- | Get the value of the “@socket@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' socketConnection #socket @ -} getSocketConnectionSocket :: (MonadIO m, IsSocketConnection o) => o -> m Gio.Socket.Socket getSocketConnectionSocket obj = liftIO $ checkUnexpectedNothing "getSocketConnectionSocket" $ B.Properties.getObjectPropertyObject obj "socket" Gio.Socket.Socket {- | Construct a `GValueConstruct` with valid value for the “@socket@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructSocketConnectionSocket :: (IsSocketConnection o, Gio.Socket.IsSocket a) => a -> IO (GValueConstruct o) constructSocketConnectionSocket val = B.Properties.constructObjectPropertyObject "socket" (Just val) #if ENABLE_OVERLOADING data SocketConnectionSocketPropertyInfo instance AttrInfo SocketConnectionSocketPropertyInfo where type AttrAllowedOps SocketConnectionSocketPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint SocketConnectionSocketPropertyInfo = Gio.Socket.IsSocket type AttrBaseTypeConstraint SocketConnectionSocketPropertyInfo = IsSocketConnection type AttrGetType SocketConnectionSocketPropertyInfo = Gio.Socket.Socket type AttrLabel SocketConnectionSocketPropertyInfo = "socket" type AttrOrigin SocketConnectionSocketPropertyInfo = SocketConnection attrGet _ = getSocketConnectionSocket attrSet _ = undefined attrConstruct _ = constructSocketConnectionSocket attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList SocketConnection type instance O.AttributeList SocketConnection = SocketConnectionAttributeList type SocketConnectionAttributeList = ('[ '("closed", Gio.IOStream.IOStreamClosedPropertyInfo), '("inputStream", Gio.IOStream.IOStreamInputStreamPropertyInfo), '("outputStream", Gio.IOStream.IOStreamOutputStreamPropertyInfo), '("socket", SocketConnectionSocketPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING socketConnectionSocket :: AttrLabelProxy "socket" socketConnectionSocket = AttrLabelProxy #endif #if ENABLE_OVERLOADING type instance O.SignalList SocketConnection = SocketConnectionSignalList type SocketConnectionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method SocketConnection::connect -- method type : OrdinaryMethod -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "SocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "SocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketAddress specifying the remote address.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : True -- Skip return : False foreign import ccall "g_socket_connection_connect" g_socket_connection_connect :: Ptr SocketConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "SocketConnection"}) Ptr Gio.SocketAddress.SocketAddress -> -- address : TInterface (Name {namespace = "Gio", name = "SocketAddress"}) Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) Ptr (Ptr GError) -> -- error IO CInt {- | Connect /@connection@/ to the specified remote address. /Since: 2.32/ -} socketConnectionConnect :: (B.CallStack.HasCallStack, MonadIO m, IsSocketConnection a, Gio.SocketAddress.IsSocketAddress b, Gio.Cancellable.IsCancellable c) => a {- ^ /@connection@/: a 'GI.Gio.Objects.SocketConnection.SocketConnection' -} -> b {- ^ /@address@/: a 'GI.Gio.Objects.SocketAddress.SocketAddress' specifying the remote address. -} -> Maybe (c) {- ^ /@cancellable@/: a @/GCancellable/@ or 'Nothing' -} -> m () {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} socketConnectionConnect connection address cancellable = liftIO $ do connection' <- unsafeManagedPtrCastPtr connection address' <- unsafeManagedPtrCastPtr address maybeCancellable <- case cancellable of Nothing -> return nullPtr Just jCancellable -> do jCancellable' <- unsafeManagedPtrCastPtr jCancellable return jCancellable' onException (do _ <- propagateGError $ g_socket_connection_connect connection' address' maybeCancellable touchManagedPtr connection touchManagedPtr address whenJust cancellable touchManagedPtr return () ) (do return () ) #if ENABLE_OVERLOADING data SocketConnectionConnectMethodInfo instance (signature ~ (b -> Maybe (c) -> m ()), MonadIO m, IsSocketConnection a, Gio.SocketAddress.IsSocketAddress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SocketConnectionConnectMethodInfo a signature where overloadedMethod _ = socketConnectionConnect #endif -- method SocketConnection::connect_async -- method type : OrdinaryMethod -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "SocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "address", argType = TInterface (Name {namespace = "Gio", name = "SocketAddress"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketAddress specifying the remote address.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %GCancellable or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GAsyncReadyCallback", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "user data for the callback", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_socket_connection_connect_async" g_socket_connection_connect_async :: Ptr SocketConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "SocketConnection"}) Ptr Gio.SocketAddress.SocketAddress -> -- address : TInterface (Name {namespace = "Gio", name = "SocketAddress"}) Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"}) FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}) Ptr () -> -- user_data : TBasicType TPtr IO () {- | Asynchronously connect /@connection@/ to the specified remote address. This clears the 'GI.Gio.Objects.Socket.Socket':@/blocking/@ flag on /@connection@/\'s underlying socket if it is currently set. Use 'GI.Gio.Objects.SocketConnection.socketConnectionConnectFinish' to retrieve the result. /Since: 2.32/ -} socketConnectionConnectAsync :: (B.CallStack.HasCallStack, MonadIO m, IsSocketConnection a, Gio.SocketAddress.IsSocketAddress b, Gio.Cancellable.IsCancellable c) => a {- ^ /@connection@/: a 'GI.Gio.Objects.SocketConnection.SocketConnection' -} -> b {- ^ /@address@/: a 'GI.Gio.Objects.SocketAddress.SocketAddress' specifying the remote address. -} -> Maybe (c) {- ^ /@cancellable@/: a @/GCancellable/@ or 'Nothing' -} -> Maybe (Gio.Callbacks.AsyncReadyCallback) {- ^ /@callback@/: a 'GI.Gio.Callbacks.AsyncReadyCallback' -} -> m () socketConnectionConnectAsync connection address cancellable callback = liftIO $ do connection' <- unsafeManagedPtrCastPtr connection address' <- unsafeManagedPtrCastPtr address maybeCancellable <- case cancellable of Nothing -> return nullPtr Just jCancellable -> do jCancellable' <- unsafeManagedPtrCastPtr jCancellable return jCancellable' maybeCallback <- case callback of Nothing -> return (castPtrToFunPtr nullPtr) Just jCallback -> do ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback)) jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback)) poke ptrcallback jCallback' return jCallback' let userData = nullPtr g_socket_connection_connect_async connection' address' maybeCancellable maybeCallback userData touchManagedPtr connection touchManagedPtr address whenJust cancellable touchManagedPtr return () #if ENABLE_OVERLOADING data SocketConnectionConnectAsyncMethodInfo instance (signature ~ (b -> Maybe (c) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsSocketConnection a, Gio.SocketAddress.IsSocketAddress b, Gio.Cancellable.IsCancellable c) => O.MethodInfo SocketConnectionConnectAsyncMethodInfo a signature where overloadedMethod _ = socketConnectionConnectAsync #endif -- method SocketConnection::connect_finish -- method type : OrdinaryMethod -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "SocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TBoolean) -- throws : True -- Skip return : False foreign import ccall "g_socket_connection_connect_finish" g_socket_connection_connect_finish :: Ptr SocketConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "SocketConnection"}) Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"}) Ptr (Ptr GError) -> -- error IO CInt {- | Gets the result of a 'GI.Gio.Objects.SocketConnection.socketConnectionConnectAsync' call. /Since: 2.32/ -} socketConnectionConnectFinish :: (B.CallStack.HasCallStack, MonadIO m, IsSocketConnection a, Gio.AsyncResult.IsAsyncResult b) => a {- ^ /@connection@/: a 'GI.Gio.Objects.SocketConnection.SocketConnection' -} -> b {- ^ /@result@/: the 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -} -> m () {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} socketConnectionConnectFinish connection result_ = liftIO $ do connection' <- unsafeManagedPtrCastPtr connection result_' <- unsafeManagedPtrCastPtr result_ onException (do _ <- propagateGError $ g_socket_connection_connect_finish connection' result_' touchManagedPtr connection touchManagedPtr result_ return () ) (do return () ) #if ENABLE_OVERLOADING data SocketConnectionConnectFinishMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsSocketConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo SocketConnectionConnectFinishMethodInfo a signature where overloadedMethod _ = socketConnectionConnectFinish #endif -- method SocketConnection::get_local_address -- method type : OrdinaryMethod -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "SocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketAddress"})) -- throws : True -- Skip return : False foreign import ccall "g_socket_connection_get_local_address" g_socket_connection_get_local_address :: Ptr SocketConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "SocketConnection"}) Ptr (Ptr GError) -> -- error IO (Ptr Gio.SocketAddress.SocketAddress) {- | Try to get the local address of a socket connection. /Since: 2.22/ -} socketConnectionGetLocalAddress :: (B.CallStack.HasCallStack, MonadIO m, IsSocketConnection a) => a {- ^ /@connection@/: a 'GI.Gio.Objects.SocketConnection.SocketConnection' -} -> m Gio.SocketAddress.SocketAddress {- ^ __Returns:__ a 'GI.Gio.Objects.SocketAddress.SocketAddress' or 'Nothing' on error. Free the returned object with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -} socketConnectionGetLocalAddress connection = liftIO $ do connection' <- unsafeManagedPtrCastPtr connection onException (do result <- propagateGError $ g_socket_connection_get_local_address connection' checkUnexpectedReturnNULL "socketConnectionGetLocalAddress" result result' <- (wrapObject Gio.SocketAddress.SocketAddress) result touchManagedPtr connection return result' ) (do return () ) #if ENABLE_OVERLOADING data SocketConnectionGetLocalAddressMethodInfo instance (signature ~ (m Gio.SocketAddress.SocketAddress), MonadIO m, IsSocketConnection a) => O.MethodInfo SocketConnectionGetLocalAddressMethodInfo a signature where overloadedMethod _ = socketConnectionGetLocalAddress #endif -- method SocketConnection::get_remote_address -- method type : OrdinaryMethod -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "SocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketAddress"})) -- throws : True -- Skip return : False foreign import ccall "g_socket_connection_get_remote_address" g_socket_connection_get_remote_address :: Ptr SocketConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "SocketConnection"}) Ptr (Ptr GError) -> -- error IO (Ptr Gio.SocketAddress.SocketAddress) {- | Try to get the remote address of a socket connection. Since GLib 2.40, when used with 'GI.Gio.Objects.SocketClient.socketClientConnect' or 'GI.Gio.Objects.SocketClient.socketClientConnectAsync', during emission of 'GI.Gio.Enums.SocketClientEventConnecting', this function will return the remote address that will be used for the connection. This allows applications to print e.g. \"Connecting to example.com (10.42.77.3)...\". /Since: 2.22/ -} socketConnectionGetRemoteAddress :: (B.CallStack.HasCallStack, MonadIO m, IsSocketConnection a) => a {- ^ /@connection@/: a 'GI.Gio.Objects.SocketConnection.SocketConnection' -} -> m Gio.SocketAddress.SocketAddress {- ^ __Returns:__ a 'GI.Gio.Objects.SocketAddress.SocketAddress' or 'Nothing' on error. Free the returned object with 'GI.GObject.Objects.Object.objectUnref'. /(Can throw 'Data.GI.Base.GError.GError')/ -} socketConnectionGetRemoteAddress connection = liftIO $ do connection' <- unsafeManagedPtrCastPtr connection onException (do result <- propagateGError $ g_socket_connection_get_remote_address connection' checkUnexpectedReturnNULL "socketConnectionGetRemoteAddress" result result' <- (wrapObject Gio.SocketAddress.SocketAddress) result touchManagedPtr connection return result' ) (do return () ) #if ENABLE_OVERLOADING data SocketConnectionGetRemoteAddressMethodInfo instance (signature ~ (m Gio.SocketAddress.SocketAddress), MonadIO m, IsSocketConnection a) => O.MethodInfo SocketConnectionGetRemoteAddressMethodInfo a signature where overloadedMethod _ = socketConnectionGetRemoteAddress #endif -- method SocketConnection::get_socket -- method type : OrdinaryMethod -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "SocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketConnection", 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 "g_socket_connection_get_socket" g_socket_connection_get_socket :: Ptr SocketConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "SocketConnection"}) IO (Ptr Gio.Socket.Socket) {- | Gets the underlying 'GI.Gio.Objects.Socket.Socket' object of the connection. This can be useful if you want to do something unusual on it not supported by the 'GI.Gio.Objects.SocketConnection.SocketConnection' APIs. /Since: 2.22/ -} socketConnectionGetSocket :: (B.CallStack.HasCallStack, MonadIO m, IsSocketConnection a) => a {- ^ /@connection@/: a 'GI.Gio.Objects.SocketConnection.SocketConnection' -} -> m Gio.Socket.Socket {- ^ __Returns:__ a 'GI.Gio.Objects.Socket.Socket' or 'Nothing' on error. -} socketConnectionGetSocket connection = liftIO $ do connection' <- unsafeManagedPtrCastPtr connection result <- g_socket_connection_get_socket connection' checkUnexpectedReturnNULL "socketConnectionGetSocket" result result' <- (newObject Gio.Socket.Socket) result touchManagedPtr connection return result' #if ENABLE_OVERLOADING data SocketConnectionGetSocketMethodInfo instance (signature ~ (m Gio.Socket.Socket), MonadIO m, IsSocketConnection a) => O.MethodInfo SocketConnectionGetSocketMethodInfo a signature where overloadedMethod _ = socketConnectionGetSocket #endif -- method SocketConnection::is_connected -- method type : OrdinaryMethod -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "SocketConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketConnection", 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 "g_socket_connection_is_connected" g_socket_connection_is_connected :: Ptr SocketConnection -> -- connection : TInterface (Name {namespace = "Gio", name = "SocketConnection"}) IO CInt {- | Checks if /@connection@/ is connected. This is equivalent to calling 'GI.Gio.Objects.Socket.socketIsConnected' on /@connection@/\'s underlying 'GI.Gio.Objects.Socket.Socket'. /Since: 2.32/ -} socketConnectionIsConnected :: (B.CallStack.HasCallStack, MonadIO m, IsSocketConnection a) => a {- ^ /@connection@/: a 'GI.Gio.Objects.SocketConnection.SocketConnection' -} -> m Bool {- ^ __Returns:__ whether /@connection@/ is connected -} socketConnectionIsConnected connection = liftIO $ do connection' <- unsafeManagedPtrCastPtr connection result <- g_socket_connection_is_connected connection' let result' = (/= 0) result touchManagedPtr connection return result' #if ENABLE_OVERLOADING data SocketConnectionIsConnectedMethodInfo instance (signature ~ (m Bool), MonadIO m, IsSocketConnection a) => O.MethodInfo SocketConnectionIsConnectedMethodInfo a signature where overloadedMethod _ = socketConnectionIsConnected #endif -- method SocketConnection::factory_lookup_type -- method type : MemberFunction -- Args : [Arg {argCName = "family", argType = TInterface (Name {namespace = "Gio", name = "SocketFamily"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketFamily", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gio", name = "SocketType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol_id", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a protocol id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TGType) -- throws : False -- Skip return : False foreign import ccall "g_socket_connection_factory_lookup_type" g_socket_connection_factory_lookup_type :: CUInt -> -- family : TInterface (Name {namespace = "Gio", name = "SocketFamily"}) CUInt -> -- type : TInterface (Name {namespace = "Gio", name = "SocketType"}) Int32 -> -- protocol_id : TBasicType TInt IO CGType {- | Looks up the 'GType' to be used when creating socket connections on sockets with the specified /@family@/, /@type@/ and /@protocolId@/. If no type is registered, the 'GI.Gio.Objects.SocketConnection.SocketConnection' base type is returned. /Since: 2.22/ -} socketConnectionFactoryLookupType :: (B.CallStack.HasCallStack, MonadIO m) => Gio.Enums.SocketFamily {- ^ /@family@/: a 'GI.Gio.Enums.SocketFamily' -} -> Gio.Enums.SocketType {- ^ /@type@/: a 'GI.Gio.Enums.SocketType' -} -> Int32 {- ^ /@protocolId@/: a protocol id -} -> m GType {- ^ __Returns:__ a 'GType' -} socketConnectionFactoryLookupType family type_ protocolId = liftIO $ do let family' = (fromIntegral . fromEnum) family let type_' = (fromIntegral . fromEnum) type_ result <- g_socket_connection_factory_lookup_type family' type_' protocolId let result' = GType result return result' #if ENABLE_OVERLOADING #endif -- method SocketConnection::factory_register_type -- method type : MemberFunction -- Args : [Arg {argCName = "g_type", argType = TBasicType TGType, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GType, inheriting from %G_TYPE_SOCKET_CONNECTION", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "family", argType = TInterface (Name {namespace = "Gio", name = "SocketFamily"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketFamily", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "Gio", name = "SocketType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketType", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocol", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a protocol id", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_socket_connection_factory_register_type" g_socket_connection_factory_register_type :: CGType -> -- g_type : TBasicType TGType CUInt -> -- family : TInterface (Name {namespace = "Gio", name = "SocketFamily"}) CUInt -> -- type : TInterface (Name {namespace = "Gio", name = "SocketType"}) Int32 -> -- protocol : TBasicType TInt IO () {- | Looks up the 'GType' to be used when creating socket connections on sockets with the specified /@family@/, /@type@/ and /@protocol@/. If no type is registered, the 'GI.Gio.Objects.SocketConnection.SocketConnection' base type is returned. /Since: 2.22/ -} socketConnectionFactoryRegisterType :: (B.CallStack.HasCallStack, MonadIO m) => GType {- ^ /@gType@/: a 'GType', inheriting from @/G_TYPE_SOCKET_CONNECTION/@ -} -> Gio.Enums.SocketFamily {- ^ /@family@/: a 'GI.Gio.Enums.SocketFamily' -} -> Gio.Enums.SocketType {- ^ /@type@/: a 'GI.Gio.Enums.SocketType' -} -> Int32 {- ^ /@protocol@/: a protocol id -} -> m () socketConnectionFactoryRegisterType gType family type_ protocol = liftIO $ do let gType' = gtypeToCGType gType let family' = (fromIntegral . fromEnum) family let type_' = (fromIntegral . fromEnum) type_ g_socket_connection_factory_register_type gType' family' type_' protocol return () #if ENABLE_OVERLOADING #endif