    {- |
    Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
    License    : LGPL-2.1
    Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

    '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 \
           (!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.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.Text as T
    import qualified Data.ByteString.Char8 as B
    import qualified Data.Map as Map
    import qualified Foreign.Ptr as FP

    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 => IsSocketConnection o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError SocketConnection a) =>
        IsSocketConnection a
    #endif
    instance IsSocketConnection SocketConnection
    instance Gio.IOStream.IsIOStream SocketConnection
    instance GObject.Object.IsObject SocketConnection

    -- | 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) => O.IsLabelProxy t (SocketConnection -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveSocketConnectionMethod t SocketConnection, O.MethodInfo info SocketConnection p) => O.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

    #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 <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> 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" $ 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 = 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