{-# 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.Kind as DK
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 Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.PollFD as GLib.PollFD
import qualified GI.GLib.Structs.Source as GLib.Source
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
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.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
#else
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
#endif
newtype UnixInputStream = UnixInputStream (SP.ManagedPtr UnixInputStream)
deriving (UnixInputStream -> UnixInputStream -> Bool
(UnixInputStream -> UnixInputStream -> Bool)
-> (UnixInputStream -> UnixInputStream -> Bool)
-> Eq UnixInputStream
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UnixInputStream -> UnixInputStream -> Bool
== :: UnixInputStream -> UnixInputStream -> Bool
$c/= :: UnixInputStream -> UnixInputStream -> Bool
/= :: 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 = IO UnixInputStream -> m UnixInputStream
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO UnixInputStream -> m UnixInputStream)
-> (o -> IO UnixInputStream) -> o -> m UnixInputStream
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr UnixInputStream -> UnixInputStream)
-> o -> IO UnixInputStream
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 = Ptr GValue -> Ptr UnixInputStream -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr UnixInputStream
forall a. Ptr a
FP.nullPtr :: FP.Ptr UnixInputStream)
gvalueSet_ Ptr GValue
gv (P.Just UnixInputStream
obj) = UnixInputStream -> (Ptr UnixInputStream -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr UnixInputStream
obj (Ptr GValue -> Ptr UnixInputStream -> IO ()
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 <- Ptr GValue -> IO (Ptr UnixInputStream)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr UnixInputStream)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newObject UnixInputStream ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveUnixInputStreamMethod (t :: Symbol) (o :: DK.Type) :: DK.Type 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 = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> Bool -> IO ()
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
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.35/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 = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Int32
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 = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Int32 -> IO (GValueConstruct o)
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.35/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, DK.Type)])
#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, DK.Type)])
#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 = IO UnixInputStream -> m UnixInputStream
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO UnixInputStream -> m UnixInputStream)
-> IO UnixInputStream -> m UnixInputStream
forall a b. (a -> b) -> a -> b
$ do
let closeFd' :: CInt
closeFd' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
closeFd
result <- Int32 -> CInt -> IO (Ptr UnixInputStream)
g_unix_input_stream_new Int32
fd CInt
closeFd'
checkUnexpectedReturnNULL "unixInputStreamNew" result
result' <- (wrapObject UnixInputStream) result
return 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 = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr UnixInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
result <- g_unix_input_stream_get_close_fd stream'
let result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
touchManagedPtr stream
return 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.35/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 = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr UnixInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
result <- g_unix_input_stream_get_fd stream'
touchManagedPtr stream
return 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.35/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 = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr UnixInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
let closeFd' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
P.fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
P.fromEnum) Bool
closeFd
g_unix_input_stream_set_close_fd stream' closeFd'
touchManagedPtr stream
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.35/docs/GI-Gio-Objects-UnixInputStream.html#v:unixInputStreamSetCloseFd"
})
#endif