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

    This is the subclass of 'GI.Gio.Objects.SocketConnection.SocketConnection' that is created
    for TCP\/IP sockets.

    /Since: 2.22/
    -}

    #define ENABLE_OVERLOADING \
           (!defined(__HADDOCK_VERSION__))

    module GI.Gio.Objects.TcpConnection
        (

    -- * Exported types
        TcpConnection(..)                       ,
        IsTcpConnection                         ,
        toTcpConnection                         ,
        noTcpConnection                         ,

     -- * Methods
    -- ** getGracefulDisconnect #method:getGracefulDisconnect#

    #if ENABLE_OVERLOADING
        TcpConnectionGetGracefulDisconnectMethodInfo,
    #endif
        tcpConnectionGetGracefulDisconnect      ,

    -- ** setGracefulDisconnect #method:setGracefulDisconnect#

    #if ENABLE_OVERLOADING
        TcpConnectionSetGracefulDisconnectMethodInfo,
    #endif
        tcpConnectionSetGracefulDisconnect      ,

     -- * Properties
    -- ** gracefulDisconnect #attr:gracefulDisconnect#
    {- | /No description available in the introspection data./
    -}
    #if ENABLE_OVERLOADING
        TcpConnectionGracefulDisconnectPropertyInfo,
    #endif
        constructTcpConnectionGracefulDisconnect,
        getTcpConnectionGracefulDisconnect      ,
        setTcpConnectionGracefulDisconnect      ,
    #if ENABLE_OVERLOADING
        tcpConnectionGracefulDisconnect         ,
    #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 {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream
    import {-# SOURCE #-} qualified GI.Gio.Objects.SocketConnection as Gio.SocketConnection

    -- | Memory-managed wrapper type.
    newtype TcpConnection = TcpConnection (ManagedPtr TcpConnection)
    foreign import ccall "g_tcp_connection_get_type"
        c_g_tcp_connection_get_type :: IO GType

    instance GObject TcpConnection where
        gobjectType _ = c_g_tcp_connection_get_type

    -- | Type class for types which can be safely cast to `TcpConnection`, for instance with `toTcpConnection`.
    class GObject o => IsTcpConnection o
    #if MIN_VERSION_base(4,9,0)
    instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError TcpConnection a) =>
        IsTcpConnection a
    #endif
    instance IsTcpConnection TcpConnection
    instance Gio.SocketConnection.IsSocketConnection TcpConnection
    instance Gio.IOStream.IsIOStream TcpConnection
    instance GObject.Object.IsObject TcpConnection

    -- | Cast to `TcpConnection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
    toTcpConnection :: (MonadIO m, IsTcpConnection o) => o -> m TcpConnection
    toTcpConnection = liftIO . unsafeCastTo TcpConnection

    -- | A convenience alias for `Nothing` :: `Maybe` `TcpConnection`.
    noTcpConnection :: Maybe TcpConnection
    noTcpConnection = Nothing

    #if ENABLE_OVERLOADING
    type family ResolveTcpConnectionMethod (t :: Symbol) (o :: *) :: * where
        ResolveTcpConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
        ResolveTcpConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
        ResolveTcpConnectionMethod "clearPending" o = Gio.IOStream.IOStreamClearPendingMethodInfo
        ResolveTcpConnectionMethod "close" o = Gio.IOStream.IOStreamCloseMethodInfo
        ResolveTcpConnectionMethod "closeAsync" o = Gio.IOStream.IOStreamCloseAsyncMethodInfo
        ResolveTcpConnectionMethod "closeFinish" o = Gio.IOStream.IOStreamCloseFinishMethodInfo
        ResolveTcpConnectionMethod "connect" o = Gio.SocketConnection.SocketConnectionConnectMethodInfo
        ResolveTcpConnectionMethod "connectAsync" o = Gio.SocketConnection.SocketConnectionConnectAsyncMethodInfo
        ResolveTcpConnectionMethod "connectFinish" o = Gio.SocketConnection.SocketConnectionConnectFinishMethodInfo
        ResolveTcpConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
        ResolveTcpConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
        ResolveTcpConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
        ResolveTcpConnectionMethod "hasPending" o = Gio.IOStream.IOStreamHasPendingMethodInfo
        ResolveTcpConnectionMethod "isClosed" o = Gio.IOStream.IOStreamIsClosedMethodInfo
        ResolveTcpConnectionMethod "isConnected" o = Gio.SocketConnection.SocketConnectionIsConnectedMethodInfo
        ResolveTcpConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
        ResolveTcpConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
        ResolveTcpConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
        ResolveTcpConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
        ResolveTcpConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
        ResolveTcpConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
        ResolveTcpConnectionMethod "spliceAsync" o = Gio.IOStream.IOStreamSpliceAsyncMethodInfo
        ResolveTcpConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
        ResolveTcpConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
        ResolveTcpConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
        ResolveTcpConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
        ResolveTcpConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
        ResolveTcpConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
        ResolveTcpConnectionMethod "getGracefulDisconnect" o = TcpConnectionGetGracefulDisconnectMethodInfo
        ResolveTcpConnectionMethod "getInputStream" o = Gio.IOStream.IOStreamGetInputStreamMethodInfo
        ResolveTcpConnectionMethod "getLocalAddress" o = Gio.SocketConnection.SocketConnectionGetLocalAddressMethodInfo
        ResolveTcpConnectionMethod "getOutputStream" o = Gio.IOStream.IOStreamGetOutputStreamMethodInfo
        ResolveTcpConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
        ResolveTcpConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
        ResolveTcpConnectionMethod "getRemoteAddress" o = Gio.SocketConnection.SocketConnectionGetRemoteAddressMethodInfo
        ResolveTcpConnectionMethod "getSocket" o = Gio.SocketConnection.SocketConnectionGetSocketMethodInfo
        ResolveTcpConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
        ResolveTcpConnectionMethod "setGracefulDisconnect" o = TcpConnectionSetGracefulDisconnectMethodInfo
        ResolveTcpConnectionMethod "setPending" o = Gio.IOStream.IOStreamSetPendingMethodInfo
        ResolveTcpConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
        ResolveTcpConnectionMethod l o = O.MethodResolutionFailed l o

    instance (info ~ ResolveTcpConnectionMethod t TcpConnection, O.MethodInfo info TcpConnection p) => O.IsLabelProxy t (TcpConnection -> p) where
        fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

    #if MIN_VERSION_base(4,9,0)
    instance (info ~ ResolveTcpConnectionMethod t TcpConnection, O.MethodInfo info TcpConnection p) => O.IsLabel t (TcpConnection -> 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 "graceful-disconnect"
       -- Type: TBasicType TBoolean
       -- Flags: [PropertyReadable,PropertyWritable]
       -- Nullable: (Just False,Just False)

    {- |
    Get the value of the “@graceful-disconnect@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.get' tcpConnection #gracefulDisconnect
    @
    -}
    getTcpConnectionGracefulDisconnect :: (MonadIO m, IsTcpConnection o) => o -> m Bool
    getTcpConnectionGracefulDisconnect obj = liftIO $ getObjectPropertyBool obj "graceful-disconnect"

    {- |
    Set the value of the “@graceful-disconnect@” property.
    When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

    @
    'Data.GI.Base.Attributes.set' tcpConnection [ #gracefulDisconnect 'Data.GI.Base.Attributes.:=' value ]
    @
    -}
    setTcpConnectionGracefulDisconnect :: (MonadIO m, IsTcpConnection o) => o -> Bool -> m ()
    setTcpConnectionGracefulDisconnect obj val = liftIO $ setObjectPropertyBool obj "graceful-disconnect" val

    {- |
    Construct a `GValueConstruct` with valid value for the “@graceful-disconnect@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
    -}
    constructTcpConnectionGracefulDisconnect :: (IsTcpConnection o) => Bool -> IO (GValueConstruct o)
    constructTcpConnectionGracefulDisconnect val = constructObjectPropertyBool "graceful-disconnect" val

    #if ENABLE_OVERLOADING
    data TcpConnectionGracefulDisconnectPropertyInfo
    instance AttrInfo TcpConnectionGracefulDisconnectPropertyInfo where
        type AttrAllowedOps TcpConnectionGracefulDisconnectPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
        type AttrSetTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = (~) Bool
        type AttrBaseTypeConstraint TcpConnectionGracefulDisconnectPropertyInfo = IsTcpConnection
        type AttrGetType TcpConnectionGracefulDisconnectPropertyInfo = Bool
        type AttrLabel TcpConnectionGracefulDisconnectPropertyInfo = "graceful-disconnect"
        type AttrOrigin TcpConnectionGracefulDisconnectPropertyInfo = TcpConnection
        attrGet _ = getTcpConnectionGracefulDisconnect
        attrSet _ = setTcpConnectionGracefulDisconnect
        attrConstruct _ = constructTcpConnectionGracefulDisconnect
        attrClear _ = undefined
    #endif

    #if ENABLE_OVERLOADING
    instance O.HasAttributeList TcpConnection
    type instance O.AttributeList TcpConnection = TcpConnectionAttributeList
    type TcpConnectionAttributeList = ('[ '("closed", Gio.IOStream.IOStreamClosedPropertyInfo), '("gracefulDisconnect", TcpConnectionGracefulDisconnectPropertyInfo), '("inputStream", Gio.IOStream.IOStreamInputStreamPropertyInfo), '("outputStream", Gio.IOStream.IOStreamOutputStreamPropertyInfo), '("socket", Gio.SocketConnection.SocketConnectionSocketPropertyInfo)] :: [(Symbol, *)])
    #endif

    #if ENABLE_OVERLOADING
    tcpConnectionGracefulDisconnect :: AttrLabelProxy "gracefulDisconnect"
    tcpConnectionGracefulDisconnect = AttrLabelProxy

    #endif

    #if ENABLE_OVERLOADING
    type instance O.SignalList TcpConnection = TcpConnectionSignalList
    type TcpConnectionSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

    #endif

    -- method TcpConnection::get_graceful_disconnect
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "TcpConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTcpConnection", 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_tcp_connection_get_graceful_disconnect" g_tcp_connection_get_graceful_disconnect ::
        Ptr TcpConnection ->                    -- connection : TInterface (Name {namespace = "Gio", name = "TcpConnection"})
        IO CInt

    {- |
    Checks if graceful disconnects are used. See
    'GI.Gio.Objects.TcpConnection.tcpConnectionSetGracefulDisconnect'.

    /Since: 2.22/
    -}
    tcpConnectionGetGracefulDisconnect ::
        (B.CallStack.HasCallStack, MonadIO m, IsTcpConnection a) =>
        a
        {- ^ /@connection@/: a 'GI.Gio.Objects.TcpConnection.TcpConnection' -}
        -> m Bool
        {- ^ __Returns:__ 'True' if graceful disconnect is used on close, 'False' otherwise -}
    tcpConnectionGetGracefulDisconnect connection = liftIO $ do
        connection' <- unsafeManagedPtrCastPtr connection
        result <- g_tcp_connection_get_graceful_disconnect connection'
        let result' = (/= 0) result
        touchManagedPtr connection
        return result'

    #if ENABLE_OVERLOADING
    data TcpConnectionGetGracefulDisconnectMethodInfo
    instance (signature ~ (m Bool), MonadIO m, IsTcpConnection a) => O.MethodInfo TcpConnectionGetGracefulDisconnectMethodInfo a signature where
        overloadedMethod _ = tcpConnectionGetGracefulDisconnect

    #endif

    -- method TcpConnection::set_graceful_disconnect
    -- method type : OrdinaryMethod
    -- Args : [Arg {argCName = "connection", argType = TInterface (Name {namespace = "Gio", name = "TcpConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTcpConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "graceful_disconnect", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether to do graceful disconnects or not", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
    -- Lengths : []
    -- returnType : Nothing
    -- throws : False
    -- Skip return : False

    foreign import ccall "g_tcp_connection_set_graceful_disconnect" g_tcp_connection_set_graceful_disconnect ::
        Ptr TcpConnection ->                    -- connection : TInterface (Name {namespace = "Gio", name = "TcpConnection"})
        CInt ->                                 -- graceful_disconnect : TBasicType TBoolean
        IO ()

    {- |
    This enables graceful disconnects on close. A graceful disconnect
    means that we signal the receiving end that the connection is terminated
    and wait for it to close the connection before closing the connection.

    A graceful disconnect means that we can be sure that we successfully sent
    all the outstanding data to the other end, or get an error reported.
    However, it also means we have to wait for all the data to reach the
    other side and for it to acknowledge this by closing the socket, which may
    take a while. For this reason it is disabled by default.

    /Since: 2.22/
    -}
    tcpConnectionSetGracefulDisconnect ::
        (B.CallStack.HasCallStack, MonadIO m, IsTcpConnection a) =>
        a
        {- ^ /@connection@/: a 'GI.Gio.Objects.TcpConnection.TcpConnection' -}
        -> Bool
        {- ^ /@gracefulDisconnect@/: Whether to do graceful disconnects or not -}
        -> m ()
    tcpConnectionSetGracefulDisconnect connection gracefulDisconnect = liftIO $ do
        connection' <- unsafeManagedPtrCastPtr connection
        let gracefulDisconnect' = (fromIntegral . fromEnum) gracefulDisconnect
        g_tcp_connection_set_graceful_disconnect connection' gracefulDisconnect'
        touchManagedPtr connection
        return ()

    #if ENABLE_OVERLOADING
    data TcpConnectionSetGracefulDisconnectMethodInfo
    instance (signature ~ (Bool -> m ()), MonadIO m, IsTcpConnection a) => O.MethodInfo TcpConnectionSetGracefulDisconnectMethodInfo a signature where
        overloadedMethod _ = tcpConnectionSetGracefulDisconnect

    #endif