{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- A t'GI.Gio.Objects.TcpWrapperConnection.TcpWrapperConnection' can be used to wrap a t'GI.Gio.Objects.IOStream.IOStream' that is
-- based on a t'GI.Gio.Objects.Socket.Socket', but which is not actually a
-- t'GI.Gio.Objects.SocketConnection.SocketConnection'. This is used by t'GI.Gio.Objects.SocketClient.SocketClient' so that it can
-- always return a t'GI.Gio.Objects.SocketConnection.SocketConnection', even when the connection it has
-- actually created is not directly a t'GI.Gio.Objects.SocketConnection.SocketConnection'.
-- 
-- /Since: 2.28/

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

module GI.Gio.Objects.TcpWrapperConnection
    ( 

-- * Exported types
    TcpWrapperConnection(..)                ,
    IsTcpWrapperConnection                  ,
    toTcpWrapperConnection                  ,
    noTcpWrapperConnection                  ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveTcpWrapperConnectionMethod       ,
#endif


-- ** getBaseIoStream #method:getBaseIoStream#

#if defined(ENABLE_OVERLOADING)
    TcpWrapperConnectionGetBaseIoStreamMethodInfo,
#endif
    tcpWrapperConnectionGetBaseIoStream     ,


-- ** new #method:new#

    tcpWrapperConnectionNew                 ,




 -- * Properties
-- ** baseIoStream #attr:baseIoStream#
-- | /No description available in the introspection data./

#if defined(ENABLE_OVERLOADING)
    TcpWrapperConnectionBaseIoStreamPropertyInfo,
#endif
    constructTcpWrapperConnectionBaseIoStream,
    getTcpWrapperConnectionBaseIoStream     ,
#if defined(ENABLE_OVERLOADING)
    tcpWrapperConnectionBaseIoStream        ,
#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.GI.Base.Signals as B.Signals
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 {-# 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.SocketConnection as Gio.SocketConnection
import {-# SOURCE #-} qualified GI.Gio.Objects.TcpConnection as Gio.TcpConnection

-- | Memory-managed wrapper type.
newtype TcpWrapperConnection = TcpWrapperConnection (ManagedPtr TcpWrapperConnection)
    deriving (TcpWrapperConnection -> TcpWrapperConnection -> Bool
(TcpWrapperConnection -> TcpWrapperConnection -> Bool)
-> (TcpWrapperConnection -> TcpWrapperConnection -> Bool)
-> Eq TcpWrapperConnection
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TcpWrapperConnection -> TcpWrapperConnection -> Bool
$c/= :: TcpWrapperConnection -> TcpWrapperConnection -> Bool
== :: TcpWrapperConnection -> TcpWrapperConnection -> Bool
$c== :: TcpWrapperConnection -> TcpWrapperConnection -> Bool
Eq)
foreign import ccall "g_tcp_wrapper_connection_get_type"
    c_g_tcp_wrapper_connection_get_type :: IO GType

instance GObject TcpWrapperConnection where
    gobjectType :: IO GType
gobjectType = IO GType
c_g_tcp_wrapper_connection_get_type
    

-- | Convert 'TcpWrapperConnection' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue TcpWrapperConnection where
    toGValue :: TcpWrapperConnection -> IO GValue
toGValue o :: TcpWrapperConnection
o = do
        GType
gtype <- IO GType
c_g_tcp_wrapper_connection_get_type
        TcpWrapperConnection
-> (Ptr TcpWrapperConnection -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TcpWrapperConnection
o (GType
-> (GValue -> Ptr TcpWrapperConnection -> IO ())
-> Ptr TcpWrapperConnection
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr TcpWrapperConnection -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO TcpWrapperConnection
fromGValue gv :: GValue
gv = do
        Ptr TcpWrapperConnection
ptr <- GValue -> IO (Ptr TcpWrapperConnection)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr TcpWrapperConnection)
        (ManagedPtr TcpWrapperConnection -> TcpWrapperConnection)
-> Ptr TcpWrapperConnection -> IO TcpWrapperConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr TcpWrapperConnection -> TcpWrapperConnection
TcpWrapperConnection Ptr TcpWrapperConnection
ptr
        
    

-- | Type class for types which can be safely cast to `TcpWrapperConnection`, for instance with `toTcpWrapperConnection`.
class (GObject o, O.IsDescendantOf TcpWrapperConnection o) => IsTcpWrapperConnection o
instance (GObject o, O.IsDescendantOf TcpWrapperConnection o) => IsTcpWrapperConnection o

instance O.HasParentTypes TcpWrapperConnection
type instance O.ParentTypes TcpWrapperConnection = '[Gio.TcpConnection.TcpConnection, Gio.SocketConnection.SocketConnection, Gio.IOStream.IOStream, GObject.Object.Object]

-- | Cast to `TcpWrapperConnection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toTcpWrapperConnection :: (MonadIO m, IsTcpWrapperConnection o) => o -> m TcpWrapperConnection
toTcpWrapperConnection :: o -> m TcpWrapperConnection
toTcpWrapperConnection = IO TcpWrapperConnection -> m TcpWrapperConnection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TcpWrapperConnection -> m TcpWrapperConnection)
-> (o -> IO TcpWrapperConnection) -> o -> m TcpWrapperConnection
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr TcpWrapperConnection -> TcpWrapperConnection)
-> o -> IO TcpWrapperConnection
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr TcpWrapperConnection -> TcpWrapperConnection
TcpWrapperConnection

-- | A convenience alias for `Nothing` :: `Maybe` `TcpWrapperConnection`.
noTcpWrapperConnection :: Maybe TcpWrapperConnection
noTcpWrapperConnection :: Maybe TcpWrapperConnection
noTcpWrapperConnection = Maybe TcpWrapperConnection
forall a. Maybe a
Nothing

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

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

#endif

-- VVV Prop "base-io-stream"
   -- Type: TInterface (Name {namespace = "Gio", name = "IOStream"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

-- | Get the value of the “@base-io-stream@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' tcpWrapperConnection #baseIoStream
-- @
getTcpWrapperConnectionBaseIoStream :: (MonadIO m, IsTcpWrapperConnection o) => o -> m Gio.IOStream.IOStream
getTcpWrapperConnectionBaseIoStream :: o -> m IOStream
getTcpWrapperConnectionBaseIoStream obj :: o
obj = IO IOStream -> m IOStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO IOStream -> m IOStream) -> IO IOStream -> m IOStream
forall a b. (a -> b) -> a -> b
$ Text -> IO (Maybe IOStream) -> IO IOStream
forall a. HasCallStack => Text -> IO (Maybe a) -> IO a
checkUnexpectedNothing "getTcpWrapperConnectionBaseIoStream" (IO (Maybe IOStream) -> IO IOStream)
-> IO (Maybe IOStream) -> IO IOStream
forall a b. (a -> b) -> a -> b
$ o
-> String
-> (ManagedPtr IOStream -> IOStream)
-> IO (Maybe IOStream)
forall a b.
(GObject a, GObject b) =>
a -> String -> (ManagedPtr b -> b) -> IO (Maybe b)
B.Properties.getObjectPropertyObject o
obj "base-io-stream" ManagedPtr IOStream -> IOStream
Gio.IOStream.IOStream

-- | Construct a `GValueConstruct` with valid value for the “@base-io-stream@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructTcpWrapperConnectionBaseIoStream :: (IsTcpWrapperConnection o, Gio.IOStream.IsIOStream a) => a -> IO (GValueConstruct o)
constructTcpWrapperConnectionBaseIoStream :: a -> IO (GValueConstruct o)
constructTcpWrapperConnectionBaseIoStream val :: a
val = String -> Maybe a -> IO (GValueConstruct o)
forall a o.
GObject a =>
String -> Maybe a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyObject "base-io-stream" (a -> Maybe a
forall a. a -> Maybe a
Just a
val)

#if defined(ENABLE_OVERLOADING)
data TcpWrapperConnectionBaseIoStreamPropertyInfo
instance AttrInfo TcpWrapperConnectionBaseIoStreamPropertyInfo where
    type AttrAllowedOps TcpWrapperConnectionBaseIoStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrBaseTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = IsTcpWrapperConnection
    type AttrSetTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IsIOStream
    type AttrTransferTypeConstraint TcpWrapperConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IsIOStream
    type AttrTransferType TcpWrapperConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IOStream
    type AttrGetType TcpWrapperConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IOStream
    type AttrLabel TcpWrapperConnectionBaseIoStreamPropertyInfo = "base-io-stream"
    type AttrOrigin TcpWrapperConnectionBaseIoStreamPropertyInfo = TcpWrapperConnection
    attrGet = getTcpWrapperConnectionBaseIoStream
    attrSet = undefined
    attrTransfer _ v = do
        unsafeCastTo Gio.IOStream.IOStream v
    attrConstruct = constructTcpWrapperConnectionBaseIoStream
    attrClear = undefined
#endif

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

#if defined(ENABLE_OVERLOADING)
tcpWrapperConnectionBaseIoStream :: AttrLabelProxy "baseIoStream"
tcpWrapperConnectionBaseIoStream = AttrLabelProxy

#endif

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

#endif

-- method TcpWrapperConnection::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "base_io_stream"
--           , argType =
--               TInterface Name { namespace = "Gio" , name = "IOStream" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GIOStream to wrap"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "socket"
--           , argType = TInterface Name { namespace = "Gio" , name = "Socket" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #GSocket associated with @base_io_stream"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "Gio" , name = "TcpWrapperConnection" })
-- throws : False
-- Skip return : False

foreign import ccall "g_tcp_wrapper_connection_new" g_tcp_wrapper_connection_new :: 
    Ptr Gio.IOStream.IOStream ->            -- base_io_stream : TInterface (Name {namespace = "Gio", name = "IOStream"})
    Ptr Gio.Socket.Socket ->                -- socket : TInterface (Name {namespace = "Gio", name = "Socket"})
    IO (Ptr TcpWrapperConnection)

-- | Wraps /@baseIoStream@/ and /@socket@/ together as a t'GI.Gio.Objects.SocketConnection.SocketConnection'.
-- 
-- /Since: 2.28/
tcpWrapperConnectionNew ::
    (B.CallStack.HasCallStack, MonadIO m, Gio.IOStream.IsIOStream a, Gio.Socket.IsSocket b) =>
    a
    -- ^ /@baseIoStream@/: the t'GI.Gio.Objects.IOStream.IOStream' to wrap
    -> b
    -- ^ /@socket@/: the t'GI.Gio.Objects.Socket.Socket' associated with /@baseIoStream@/
    -> m TcpWrapperConnection
    -- ^ __Returns:__ the new t'GI.Gio.Objects.SocketConnection.SocketConnection'.
tcpWrapperConnectionNew :: a -> b -> m TcpWrapperConnection
tcpWrapperConnectionNew baseIoStream :: a
baseIoStream socket :: b
socket = IO TcpWrapperConnection -> m TcpWrapperConnection
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TcpWrapperConnection -> m TcpWrapperConnection)
-> IO TcpWrapperConnection -> m TcpWrapperConnection
forall a b. (a -> b) -> a -> b
$ do
    Ptr IOStream
baseIoStream' <- a -> IO (Ptr IOStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
baseIoStream
    Ptr Socket
socket' <- b -> IO (Ptr Socket)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
socket
    Ptr TcpWrapperConnection
result <- Ptr IOStream -> Ptr Socket -> IO (Ptr TcpWrapperConnection)
g_tcp_wrapper_connection_new Ptr IOStream
baseIoStream' Ptr Socket
socket'
    Text -> Ptr TcpWrapperConnection -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "tcpWrapperConnectionNew" Ptr TcpWrapperConnection
result
    TcpWrapperConnection
result' <- ((ManagedPtr TcpWrapperConnection -> TcpWrapperConnection)
-> Ptr TcpWrapperConnection -> IO TcpWrapperConnection
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr TcpWrapperConnection -> TcpWrapperConnection
TcpWrapperConnection) Ptr TcpWrapperConnection
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
baseIoStream
    b -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
socket
    TcpWrapperConnection -> IO TcpWrapperConnection
forall (m :: * -> *) a. Monad m => a -> m a
return TcpWrapperConnection
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method TcpWrapperConnection::get_base_io_stream
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "conn"
--           , argType =
--               TInterface
--                 Name { namespace = "Gio" , name = "TcpWrapperConnection" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #GTcpWrapperConnection"
--                 , 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 "g_tcp_wrapper_connection_get_base_io_stream" g_tcp_wrapper_connection_get_base_io_stream :: 
    Ptr TcpWrapperConnection ->             -- conn : TInterface (Name {namespace = "Gio", name = "TcpWrapperConnection"})
    IO (Ptr Gio.IOStream.IOStream)

-- | Get\'s /@conn@/\'s base t'GI.Gio.Objects.IOStream.IOStream'
tcpWrapperConnectionGetBaseIoStream ::
    (B.CallStack.HasCallStack, MonadIO m, IsTcpWrapperConnection a) =>
    a
    -- ^ /@conn@/: a t'GI.Gio.Objects.TcpWrapperConnection.TcpWrapperConnection'
    -> m Gio.IOStream.IOStream
    -- ^ __Returns:__ /@conn@/\'s base t'GI.Gio.Objects.IOStream.IOStream'
tcpWrapperConnectionGetBaseIoStream :: a -> m IOStream
tcpWrapperConnectionGetBaseIoStream conn :: a
conn = IO IOStream -> m IOStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO IOStream -> m IOStream) -> IO IOStream -> m IOStream
forall a b. (a -> b) -> a -> b
$ do
    Ptr TcpWrapperConnection
conn' <- a -> IO (Ptr TcpWrapperConnection)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
conn
    Ptr IOStream
result <- Ptr TcpWrapperConnection -> IO (Ptr IOStream)
g_tcp_wrapper_connection_get_base_io_stream Ptr TcpWrapperConnection
conn'
    Text -> Ptr IOStream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "tcpWrapperConnectionGetBaseIoStream" Ptr IOStream
result
    IOStream
result' <- ((ManagedPtr IOStream -> IOStream) -> Ptr IOStream -> IO IOStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr IOStream -> IOStream
Gio.IOStream.IOStream) Ptr IOStream
result
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
conn
    IOStream -> IO IOStream
forall (m :: * -> *) a. Monad m => a -> m a
return IOStream
result'

#if defined(ENABLE_OVERLOADING)
data TcpWrapperConnectionGetBaseIoStreamMethodInfo
instance (signature ~ (m Gio.IOStream.IOStream), MonadIO m, IsTcpWrapperConnection a) => O.MethodInfo TcpWrapperConnectionGetBaseIoStreamMethodInfo a signature where
    overloadedMethod = tcpWrapperConnectionGetBaseIoStream

#endif