{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.UnixInputStream
(
UnixInputStream(..) ,
IsUnixInputStream ,
toUnixInputStream ,
#if defined(ENABLE_OVERLOADING)
ResolveUnixInputStreamMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
UnixInputStreamGetCloseFdMethodInfo ,
#endif
unixInputStreamGetCloseFd ,
#if defined(ENABLE_OVERLOADING)
UnixInputStreamGetFdMethodInfo ,
#endif
unixInputStreamGetFd ,
unixInputStreamNew ,
#if defined(ENABLE_OVERLOADING)
UnixInputStreamSetCloseFdMethodInfo ,
#endif
unixInputStreamSetCloseFd ,
#if defined(ENABLE_OVERLOADING)
UnixInputStreamCloseFdPropertyInfo ,
#endif
constructUnixInputStreamCloseFd ,
getUnixInputStreamCloseFd ,
setUnixInputStreamCloseFd ,
#if defined(ENABLE_OVERLOADING)
unixInputStreamCloseFd ,
#endif
#if defined(ENABLE_OVERLOADING)
UnixInputStreamFdPropertyInfo ,
#endif
constructUnixInputStreamFd ,
getUnixInputStreamFd ,
#if defined(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.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
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 Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
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 GHC.Records as R
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
newtype UnixInputStream = UnixInputStream (SP.ManagedPtr UnixInputStream)
deriving (UnixInputStream -> UnixInputStream -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UnixInputStream -> UnixInputStream -> Bool
$c/= :: UnixInputStream -> UnixInputStream -> Bool
== :: UnixInputStream -> UnixInputStream -> Bool
$c== :: UnixInputStream -> UnixInputStream -> Bool
Eq)
instance SP.ManagedPtrNewtype UnixInputStream where
toManagedPtr :: UnixInputStream -> ManagedPtr UnixInputStream
toManagedPtr (UnixInputStream ManagedPtr UnixInputStream
p) = ManagedPtr UnixInputStream
p
foreign import ccall "g_unix_input_stream_get_type"
c_g_unix_input_stream_get_type :: IO B.Types.GType
instance B.Types.TypedObject UnixInputStream where
glibType :: IO GType
glibType = IO GType
c_g_unix_input_stream_get_type
instance B.Types.GObject UnixInputStream
class (SP.GObject o, O.IsDescendantOf UnixInputStream o) => IsUnixInputStream o
instance (SP.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]
toUnixInputStream :: (MIO.MonadIO m, IsUnixInputStream o) => o -> m UnixInputStream
toUnixInputStream :: forall (m :: * -> *) o.
(MonadIO m, IsUnixInputStream o) =>
o -> m UnixInputStream
toUnixInputStream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr UnixInputStream -> UnixInputStream
UnixInputStream
instance B.GValue.IsGValue (Maybe UnixInputStream) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_unix_input_stream_get_type
gvalueSet_ :: Ptr GValue -> Maybe UnixInputStream -> IO ()
gvalueSet_ Ptr GValue
gv Maybe UnixInputStream
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr UnixInputStream)
gvalueSet_ Ptr GValue
gv (P.Just UnixInputStream
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UnixInputStream
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe UnixInputStream)
gvalueGet_ Ptr GValue
gv = do
Ptr UnixInputStream
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr UnixInputStream)
if Ptr UnixInputStream
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr UnixInputStream -> UnixInputStream
UnixInputStream Ptr UnixInputStream
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(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 "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
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.OverloadedMethod info UnixInputStream p) => OL.IsLabel t (UnixInputStream -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveUnixInputStreamMethod t UnixInputStream, O.OverloadedMethod info UnixInputStream p, R.HasField t UnixInputStream p) => R.HasField t UnixInputStream p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveUnixInputStreamMethod t UnixInputStream, O.OverloadedMethodInfo info UnixInputStream) => OL.IsLabel t (O.MethodProxy info UnixInputStream) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getUnixInputStreamCloseFd :: (MonadIO m, IsUnixInputStream o) => o -> m Bool
getUnixInputStreamCloseFd :: forall (m :: * -> *) o.
(MonadIO m, IsUnixInputStream o) =>
o -> m Bool
getUnixInputStreamCloseFd o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"close-fd"
setUnixInputStreamCloseFd :: (MonadIO m, IsUnixInputStream o) => o -> Bool -> m ()
setUnixInputStreamCloseFd :: forall (m :: * -> *) o.
(MonadIO m, IsUnixInputStream o) =>
o -> Bool -> m ()
setUnixInputStreamCloseFd o
obj Bool
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall a. GObject a => a -> String -> Bool -> IO ()
B.Properties.setObjectPropertyBool o
obj String
"close-fd" Bool
val
constructUnixInputStreamCloseFd :: (IsUnixInputStream o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructUnixInputStreamCloseFd :: forall o (m :: * -> *).
(IsUnixInputStream o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructUnixInputStreamCloseFd Bool
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"close-fd" Bool
val
#if defined(ENABLE_OVERLOADING)
data UnixInputStreamCloseFdPropertyInfo
instance AttrInfo UnixInputStreamCloseFdPropertyInfo where
type AttrAllowedOps UnixInputStreamCloseFdPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint UnixInputStreamCloseFdPropertyInfo = IsUnixInputStream
type AttrSetTypeConstraint UnixInputStreamCloseFdPropertyInfo = (~) Bool
type AttrTransferTypeConstraint UnixInputStreamCloseFdPropertyInfo = (~) Bool
type AttrTransferType UnixInputStreamCloseFdPropertyInfo = Bool
type AttrGetType UnixInputStreamCloseFdPropertyInfo = Bool
type AttrLabel UnixInputStreamCloseFdPropertyInfo = "close-fd"
type AttrOrigin UnixInputStreamCloseFdPropertyInfo = UnixInputStream
attrGet = getUnixInputStreamCloseFd
attrSet = setUnixInputStreamCloseFd
attrTransfer _ v = do
return v
attrConstruct = constructUnixInputStreamCloseFd
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixInputStream.closeFd"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixInputStream.html#g:attr:closeFd"
})
#endif
getUnixInputStreamFd :: (MonadIO m, IsUnixInputStream o) => o -> m Int32
getUnixInputStreamFd :: forall (m :: * -> *) o.
(MonadIO m, IsUnixInputStream o) =>
o -> m Int32
getUnixInputStreamFd o
obj = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall a. GObject a => a -> String -> IO Int32
B.Properties.getObjectPropertyInt32 o
obj String
"fd"
constructUnixInputStreamFd :: (IsUnixInputStream o, MIO.MonadIO m) => Int32 -> m (GValueConstruct o)
constructUnixInputStreamFd :: forall o (m :: * -> *).
(IsUnixInputStream o, MonadIO m) =>
Int32 -> m (GValueConstruct o)
constructUnixInputStreamFd Int32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ do
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall a b. (a -> b) -> a -> b
$ forall o. String -> Int32 -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyInt32 String
"fd" Int32
val
#if defined(ENABLE_OVERLOADING)
data UnixInputStreamFdPropertyInfo
instance AttrInfo UnixInputStreamFdPropertyInfo where
type AttrAllowedOps UnixInputStreamFdPropertyInfo = '[ 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint UnixInputStreamFdPropertyInfo = IsUnixInputStream
type AttrSetTypeConstraint UnixInputStreamFdPropertyInfo = (~) Int32
type AttrTransferTypeConstraint UnixInputStreamFdPropertyInfo = (~) Int32
type AttrTransferType UnixInputStreamFdPropertyInfo = Int32
type AttrGetType UnixInputStreamFdPropertyInfo = Int32
type AttrLabel UnixInputStreamFdPropertyInfo = "fd"
type AttrOrigin UnixInputStreamFdPropertyInfo = UnixInputStream
attrGet = getUnixInputStreamFd
attrSet = undefined
attrTransfer _ v = do
return v
attrConstruct = constructUnixInputStreamFd
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixInputStream.fd"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixInputStream.html#g:attr:fd"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList UnixInputStream
type instance O.AttributeList UnixInputStream = UnixInputStreamAttributeList
type UnixInputStreamAttributeList = ('[ '("closeFd", UnixInputStreamCloseFdPropertyInfo), '("fd", UnixInputStreamFdPropertyInfo)] :: [(Symbol, *)])
#endif
#if defined(ENABLE_OVERLOADING)
unixInputStreamCloseFd :: AttrLabelProxy "closeFd"
unixInputStreamCloseFd = AttrLabelProxy
unixInputStreamFd :: AttrLabelProxy "fd"
unixInputStreamFd = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList UnixInputStream = UnixInputStreamSignalList
type UnixInputStreamSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_unix_input_stream_new" g_unix_input_stream_new ::
Int32 ->
CInt ->
IO (Ptr UnixInputStream)
unixInputStreamNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
Int32
-> Bool
-> m UnixInputStream
unixInputStreamNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Int32 -> Bool -> m UnixInputStream
unixInputStreamNew Int32
fd Bool
closeFd = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let closeFd' :: CInt
closeFd' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
closeFd
Ptr UnixInputStream
result <- Int32 -> CInt -> IO (Ptr UnixInputStream)
g_unix_input_stream_new Int32
fd CInt
closeFd'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unixInputStreamNew" Ptr UnixInputStream
result
UnixInputStream
result' <- (forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UnixInputStream -> UnixInputStream
UnixInputStream) Ptr UnixInputStream
result
forall (m :: * -> *) a. Monad m => a -> m a
return UnixInputStream
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_unix_input_stream_get_close_fd" g_unix_input_stream_get_close_fd ::
Ptr UnixInputStream ->
IO CInt
unixInputStreamGetCloseFd ::
(B.CallStack.HasCallStack, MonadIO m, IsUnixInputStream a) =>
a
-> m Bool
unixInputStreamGetCloseFd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnixInputStream a) =>
a -> m Bool
unixInputStreamGetCloseFd a
stream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr UnixInputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
CInt
result <- Ptr UnixInputStream -> IO CInt
g_unix_input_stream_get_close_fd Ptr UnixInputStream
stream'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data UnixInputStreamGetCloseFdMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUnixInputStream a) => O.OverloadedMethod UnixInputStreamGetCloseFdMethodInfo a signature where
overloadedMethod = unixInputStreamGetCloseFd
instance O.OverloadedMethodInfo UnixInputStreamGetCloseFdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixInputStream.unixInputStreamGetCloseFd",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixInputStream.html#v:unixInputStreamGetCloseFd"
})
#endif
foreign import ccall "g_unix_input_stream_get_fd" g_unix_input_stream_get_fd ::
Ptr UnixInputStream ->
IO Int32
unixInputStreamGetFd ::
(B.CallStack.HasCallStack, MonadIO m, IsUnixInputStream a) =>
a
-> m Int32
unixInputStreamGetFd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnixInputStream a) =>
a -> m Int32
unixInputStreamGetFd a
stream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr UnixInputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Int32
result <- Ptr UnixInputStream -> IO Int32
g_unix_input_stream_get_fd Ptr UnixInputStream
stream'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if defined(ENABLE_OVERLOADING)
data UnixInputStreamGetFdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsUnixInputStream a) => O.OverloadedMethod UnixInputStreamGetFdMethodInfo a signature where
overloadedMethod = unixInputStreamGetFd
instance O.OverloadedMethodInfo UnixInputStreamGetFdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixInputStream.unixInputStreamGetFd",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixInputStream.html#v:unixInputStreamGetFd"
})
#endif
foreign import ccall "g_unix_input_stream_set_close_fd" g_unix_input_stream_set_close_fd ::
Ptr UnixInputStream ->
CInt ->
IO ()
unixInputStreamSetCloseFd ::
(B.CallStack.HasCallStack, MonadIO m, IsUnixInputStream a) =>
a
-> Bool
-> m ()
unixInputStreamSetCloseFd :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsUnixInputStream a) =>
a -> Bool -> m ()
unixInputStreamSetCloseFd a
stream Bool
closeFd = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr UnixInputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
let closeFd' :: CInt
closeFd' = (forall a b. (Integral a, Num b) => a -> b
fromIntegral forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Enum a => a -> Int
fromEnum) Bool
closeFd
Ptr UnixInputStream -> CInt -> IO ()
g_unix_input_stream_set_close_fd Ptr UnixInputStream
stream' CInt
closeFd'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data UnixInputStreamSetCloseFdMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsUnixInputStream a) => O.OverloadedMethod UnixInputStreamSetCloseFdMethodInfo a signature where
overloadedMethod = unixInputStreamSetCloseFd
instance O.OverloadedMethodInfo UnixInputStreamSetCloseFdMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.UnixInputStream.unixInputStreamSetCloseFd",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-UnixInputStream.html#v:unixInputStreamSetCloseFd"
})
#endif