UnixInputStream.hs


{- |
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.UnixInputStream.UnixInputStream' implements 'GI.Gio.Objects.InputStream.InputStream' for reading from a UNIX
file descriptor, including asynchronous operations. (If the file
descriptor refers to a socket or pipe, this will use @/poll()/@ to do
asynchronous I\/O. If it refers to a regular file, it will fall back
to doing asynchronous I\/O in another thread.)

Note that @\<gio\/gunixinputstream.h>@ belongs to the UNIX-specific GIO
interfaces, thus you have to use the @gio-unix-2.0.pc@ pkg-config
file when using it.
-}

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

module GI.Gio.Objects.UnixInputStream
    ( 

-- * Exported types
    UnixInputStream(..)                     ,
    IsUnixInputStream                       ,
    toUnixInputStream                       ,
    noUnixInputStream                       ,


 -- * Methods
-- ** getCloseFd #method:getCloseFd#

#if ENABLE_OVERLOADING
    UnixInputStreamGetCloseFdMethodInfo     ,
#endif
    unixInputStreamGetCloseFd               ,


-- ** getFd #method:getFd#

#if ENABLE_OVERLOADING
    UnixInputStreamGetFdMethodInfo          ,
#endif
    unixInputStreamGetFd                    ,


-- ** new #method:new#

    unixInputStreamNew                      ,


-- ** setCloseFd #method:setCloseFd#

#if ENABLE_OVERLOADING
    UnixInputStreamSetCloseFdMethodInfo     ,
#endif
    unixInputStreamSetCloseFd               ,




 -- * Properties
-- ** closeFd #attr:closeFd#
{- | Whether to close the file descriptor when the stream is closed.

/Since: 2.20/
-}
#if ENABLE_OVERLOADING
    UnixInputStreamCloseFdPropertyInfo      ,
#endif
    constructUnixInputStreamCloseFd         ,
    getUnixInputStreamCloseFd               ,
    setUnixInputStreamCloseFd               ,
#if ENABLE_OVERLOADING
    unixInputStreamCloseFd                  ,
#endif


-- ** fd #attr:fd#
{- | The file descriptor that the stream reads from.

/Since: 2.20/
-}
#if ENABLE_OVERLOADING
    UnixInputStreamFdPropertyInfo           ,
#endif
    constructUnixInputStreamFd              ,
    getUnixInputStreamFd                    ,
#if ENABLE_OVERLOADING
    unixInputStreamFd                       ,
#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 {-# SOURCE #-} qualified GI.Gio.Interfaces.FileDescriptorBased as Gio.FileDescriptorBased
import {-# SOURCE #-} qualified GI.Gio.Interfaces.PollableInputStream as Gio.PollableInputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream

-- | Memory-managed wrapper type.
newtype UnixInputStream = UnixInputStream (ManagedPtr UnixInputStream)
foreign import ccall "g_unix_input_stream_get_type"
    c_g_unix_input_stream_get_type :: IO GType

instance GObject UnixInputStream where
    gobjectType = c_g_unix_input_stream_get_type
    

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

instance O.HasParentTypes UnixInputStream
type instance O.ParentTypes UnixInputStream = '[Gio.InputStream.InputStream, GObject.Object.Object, Gio.FileDescriptorBased.FileDescriptorBased, Gio.PollableInputStream.PollableInputStream]

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

-- | A convenience alias for `Nothing` :: `Maybe` `UnixInputStream`.
noUnixInputStream :: Maybe UnixInputStream
noUnixInputStream = Nothing

#if ENABLE_OVERLOADING
type family ResolveUnixInputStreamMethod (t :: Symbol) (o :: *) :: * where
    ResolveUnixInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveUnixInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveUnixInputStreamMethod "canPoll" o = Gio.PollableInputStream.PollableInputStreamCanPollMethodInfo
    ResolveUnixInputStreamMethod "clearPending" o = Gio.InputStream.InputStreamClearPendingMethodInfo
    ResolveUnixInputStreamMethod "close" o = Gio.InputStream.InputStreamCloseMethodInfo
    ResolveUnixInputStreamMethod "closeAsync" o = Gio.InputStream.InputStreamCloseAsyncMethodInfo
    ResolveUnixInputStreamMethod "closeFinish" o = Gio.InputStream.InputStreamCloseFinishMethodInfo
    ResolveUnixInputStreamMethod "createSource" o = Gio.PollableInputStream.PollableInputStreamCreateSourceMethodInfo
    ResolveUnixInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveUnixInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveUnixInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveUnixInputStreamMethod "hasPending" o = Gio.InputStream.InputStreamHasPendingMethodInfo
    ResolveUnixInputStreamMethod "isClosed" o = Gio.InputStream.InputStreamIsClosedMethodInfo
    ResolveUnixInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveUnixInputStreamMethod "isReadable" o = Gio.PollableInputStream.PollableInputStreamIsReadableMethodInfo
    ResolveUnixInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveUnixInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveUnixInputStreamMethod "read" o = Gio.InputStream.InputStreamReadMethodInfo
    ResolveUnixInputStreamMethod "readAll" o = Gio.InputStream.InputStreamReadAllMethodInfo
    ResolveUnixInputStreamMethod "readAllAsync" o = Gio.InputStream.InputStreamReadAllAsyncMethodInfo
    ResolveUnixInputStreamMethod "readAllFinish" o = Gio.InputStream.InputStreamReadAllFinishMethodInfo
    ResolveUnixInputStreamMethod "readAsync" o = Gio.InputStream.InputStreamReadAsyncMethodInfo
    ResolveUnixInputStreamMethod "readBytes" o = Gio.InputStream.InputStreamReadBytesMethodInfo
    ResolveUnixInputStreamMethod "readBytesAsync" o = Gio.InputStream.InputStreamReadBytesAsyncMethodInfo
    ResolveUnixInputStreamMethod "readBytesFinish" o = Gio.InputStream.InputStreamReadBytesFinishMethodInfo
    ResolveUnixInputStreamMethod "readFinish" o = Gio.InputStream.InputStreamReadFinishMethodInfo
    ResolveUnixInputStreamMethod "readNonblocking" o = Gio.PollableInputStream.PollableInputStreamReadNonblockingMethodInfo
    ResolveUnixInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveUnixInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveUnixInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveUnixInputStreamMethod "skip" o = Gio.InputStream.InputStreamSkipMethodInfo
    ResolveUnixInputStreamMethod "skipAsync" o = Gio.InputStream.InputStreamSkipAsyncMethodInfo
    ResolveUnixInputStreamMethod "skipFinish" o = Gio.InputStream.InputStreamSkipFinishMethodInfo
    ResolveUnixInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveUnixInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveUnixInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveUnixInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveUnixInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveUnixInputStreamMethod "getCloseFd" o = UnixInputStreamGetCloseFdMethodInfo
    ResolveUnixInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveUnixInputStreamMethod "getFd" o = UnixInputStreamGetFdMethodInfo
    ResolveUnixInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveUnixInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveUnixInputStreamMethod "setCloseFd" o = UnixInputStreamSetCloseFdMethodInfo
    ResolveUnixInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveUnixInputStreamMethod "setPending" o = Gio.InputStream.InputStreamSetPendingMethodInfo
    ResolveUnixInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveUnixInputStreamMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveUnixInputStreamMethod t UnixInputStream, O.MethodInfo info UnixInputStream p) => OL.IsLabel t (UnixInputStream -> 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 "close-fd"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable]
   -- Nullable: (Just False,Just False)

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

@
'Data.GI.Base.Attributes.get' unixInputStream #closeFd
@
-}
getUnixInputStreamCloseFd :: (MonadIO m, IsUnixInputStream o) => o -> m Bool
getUnixInputStreamCloseFd obj = liftIO $ B.Properties.getObjectPropertyBool obj "close-fd"

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

@
'Data.GI.Base.Attributes.set' unixInputStream [ #closeFd 'Data.GI.Base.Attributes.:=' value ]
@
-}
setUnixInputStreamCloseFd :: (MonadIO m, IsUnixInputStream o) => o -> Bool -> m ()
setUnixInputStreamCloseFd obj val = liftIO $ B.Properties.setObjectPropertyBool obj "close-fd" val

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

#if ENABLE_OVERLOADING
data UnixInputStreamCloseFdPropertyInfo
instance AttrInfo UnixInputStreamCloseFdPropertyInfo where
    type AttrAllowedOps UnixInputStreamCloseFdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint UnixInputStreamCloseFdPropertyInfo = (~) Bool
    type AttrBaseTypeConstraint UnixInputStreamCloseFdPropertyInfo = IsUnixInputStream
    type AttrGetType UnixInputStreamCloseFdPropertyInfo = Bool
    type AttrLabel UnixInputStreamCloseFdPropertyInfo = "close-fd"
    type AttrOrigin UnixInputStreamCloseFdPropertyInfo = UnixInputStream
    attrGet _ = getUnixInputStreamCloseFd
    attrSet _ = setUnixInputStreamCloseFd
    attrConstruct _ = constructUnixInputStreamCloseFd
    attrClear _ = undefined
#endif

-- VVV Prop "fd"
   -- Type: TBasicType TInt
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

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

@
'Data.GI.Base.Attributes.get' unixInputStream #fd
@
-}
getUnixInputStreamFd :: (MonadIO m, IsUnixInputStream o) => o -> m Int32
getUnixInputStreamFd obj = liftIO $ B.Properties.getObjectPropertyInt32 obj "fd"

{- |
Construct a `GValueConstruct` with valid value for the “@fd@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructUnixInputStreamFd :: (IsUnixInputStream o) => Int32 -> IO (GValueConstruct o)
constructUnixInputStreamFd val = B.Properties.constructObjectPropertyInt32 "fd" val

#if ENABLE_OVERLOADING
data UnixInputStreamFdPropertyInfo
instance AttrInfo UnixInputStreamFdPropertyInfo where
    type AttrAllowedOps UnixInputStreamFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrSetTypeConstraint UnixInputStreamFdPropertyInfo = (~) Int32
    type AttrBaseTypeConstraint UnixInputStreamFdPropertyInfo = IsUnixInputStream
    type AttrGetType UnixInputStreamFdPropertyInfo = Int32
    type AttrLabel UnixInputStreamFdPropertyInfo = "fd"
    type AttrOrigin UnixInputStreamFdPropertyInfo = UnixInputStream
    attrGet _ = getUnixInputStreamFd
    attrSet _ = undefined
    attrConstruct _ = constructUnixInputStreamFd
    attrClear _ = undefined
#endif

#if ENABLE_OVERLOADING
instance O.HasAttributeList UnixInputStream
type instance O.AttributeList UnixInputStream = UnixInputStreamAttributeList
type UnixInputStreamAttributeList = ('[ '("closeFd", UnixInputStreamCloseFdPropertyInfo), '("fd", UnixInputStreamFdPropertyInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
unixInputStreamCloseFd :: AttrLabelProxy "closeFd"
unixInputStreamCloseFd = AttrLabelProxy

unixInputStreamFd :: AttrLabelProxy "fd"
unixInputStreamFd = AttrLabelProxy

#endif

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

#endif

-- method UnixInputStream::new
-- method type : Constructor
-- Args : [Arg {argCName = "fd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a UNIX file descriptor", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to close the file descriptor when done", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "UnixInputStream"}))
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_input_stream_new" g_unix_input_stream_new :: 
    Int32 ->                                -- fd : TBasicType TInt
    CInt ->                                 -- close_fd : TBasicType TBoolean
    IO (Ptr UnixInputStream)

{- |
Creates a new 'GI.Gio.Objects.UnixInputStream.UnixInputStream' for the given /@fd@/.

If /@closeFd@/ is 'True', the file descriptor will be closed
when the stream is closed.
-}
unixInputStreamNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    Int32
    {- ^ /@fd@/: a UNIX file descriptor -}
    -> Bool
    {- ^ /@closeFd@/: 'True' to close the file descriptor when done -}
    -> m UnixInputStream
    {- ^ __Returns:__ a new 'GI.Gio.Objects.UnixInputStream.UnixInputStream' -}
unixInputStreamNew fd closeFd = liftIO $ do
    let closeFd' = (fromIntegral . fromEnum) closeFd
    result <- g_unix_input_stream_new fd closeFd'
    checkUnexpectedReturnNULL "unixInputStreamNew" result
    result' <- (wrapObject UnixInputStream) result
    return result'

#if ENABLE_OVERLOADING
#endif

-- method UnixInputStream::get_close_fd
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "UnixInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GUnixInputStream", 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_unix_input_stream_get_close_fd" g_unix_input_stream_get_close_fd :: 
    Ptr UnixInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "UnixInputStream"})
    IO CInt

{- |
Returns whether the file descriptor of /@stream@/ will be
closed when the stream is closed.

/Since: 2.20/
-}
unixInputStreamGetCloseFd ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnixInputStream a) =>
    a
    {- ^ /@stream@/: a 'GI.Gio.Objects.UnixInputStream.UnixInputStream' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if the file descriptor is closed when done -}
unixInputStreamGetCloseFd stream = liftIO $ do
    stream' <- unsafeManagedPtrCastPtr stream
    result <- g_unix_input_stream_get_close_fd stream'
    let result' = (/= 0) result
    touchManagedPtr stream
    return result'

#if ENABLE_OVERLOADING
data UnixInputStreamGetCloseFdMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUnixInputStream a) => O.MethodInfo UnixInputStreamGetCloseFdMethodInfo a signature where
    overloadedMethod _ = unixInputStreamGetCloseFd

#endif

-- method UnixInputStream::get_fd
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "UnixInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GUnixInputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TInt)
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_input_stream_get_fd" g_unix_input_stream_get_fd :: 
    Ptr UnixInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "UnixInputStream"})
    IO Int32

{- |
Return the UNIX file descriptor that the stream reads from.

/Since: 2.20/
-}
unixInputStreamGetFd ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnixInputStream a) =>
    a
    {- ^ /@stream@/: a 'GI.Gio.Objects.UnixInputStream.UnixInputStream' -}
    -> m Int32
    {- ^ __Returns:__ The file descriptor of /@stream@/ -}
unixInputStreamGetFd stream = liftIO $ do
    stream' <- unsafeManagedPtrCastPtr stream
    result <- g_unix_input_stream_get_fd stream'
    touchManagedPtr stream
    return result

#if ENABLE_OVERLOADING
data UnixInputStreamGetFdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsUnixInputStream a) => O.MethodInfo UnixInputStreamGetFdMethodInfo a signature where
    overloadedMethod _ = unixInputStreamGetFd

#endif

-- method UnixInputStream::set_close_fd
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "stream", argType = TInterface (Name {namespace = "Gio", name = "UnixInputStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GUnixInputStream", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "close_fd", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to close the file descriptor when done", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "g_unix_input_stream_set_close_fd" g_unix_input_stream_set_close_fd :: 
    Ptr UnixInputStream ->                  -- stream : TInterface (Name {namespace = "Gio", name = "UnixInputStream"})
    CInt ->                                 -- close_fd : TBasicType TBoolean
    IO ()

{- |
Sets whether the file descriptor of /@stream@/ shall be closed
when the stream is closed.

/Since: 2.20/
-}
unixInputStreamSetCloseFd ::
    (B.CallStack.HasCallStack, MonadIO m, IsUnixInputStream a) =>
    a
    {- ^ /@stream@/: a 'GI.Gio.Objects.UnixInputStream.UnixInputStream' -}
    -> Bool
    {- ^ /@closeFd@/: 'True' to close the file descriptor when done -}
    -> m ()
unixInputStreamSetCloseFd stream closeFd = liftIO $ do
    stream' <- unsafeManagedPtrCastPtr stream
    let closeFd' = (fromIntegral . fromEnum) closeFd
    g_unix_input_stream_set_close_fd stream' closeFd'
    touchManagedPtr stream
    return ()

#if ENABLE_OVERLOADING
data UnixInputStreamSetCloseFdMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsUnixInputStream a) => O.MethodInfo UnixInputStreamSetCloseFdMethodInfo a signature where
    overloadedMethod _ = unixInputStreamSetCloseFd

#endif