#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.Gio.Objects.UnixInputStream
(
UnixInputStream(..) ,
IsUnixInputStream ,
toUnixInputStream ,
noUnixInputStream ,
#if ENABLE_OVERLOADING
UnixInputStreamGetCloseFdMethodInfo ,
#endif
unixInputStreamGetCloseFd ,
#if ENABLE_OVERLOADING
UnixInputStreamGetFdMethodInfo ,
#endif
unixInputStreamGetFd ,
unixInputStreamNew ,
#if ENABLE_OVERLOADING
UnixInputStreamSetCloseFdMethodInfo ,
#endif
unixInputStreamSetCloseFd ,
#if ENABLE_OVERLOADING
UnixInputStreamCloseFdPropertyInfo ,
#endif
constructUnixInputStreamCloseFd ,
getUnixInputStreamCloseFd ,
setUnixInputStreamCloseFd ,
#if ENABLE_OVERLOADING
unixInputStreamCloseFd ,
#endif
#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.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.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 (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 :: UnixInputStream -> IO GType
gobjectType _ = IO GType
c_g_unix_input_stream_get_type
class GObject o => IsUnixInputStream o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError UnixInputStream a) =>
IsUnixInputStream a
#endif
instance IsUnixInputStream UnixInputStream
instance Gio.InputStream.IsInputStream UnixInputStream
instance GObject.Object.IsObject UnixInputStream
instance Gio.FileDescriptorBased.IsFileDescriptorBased UnixInputStream
instance Gio.PollableInputStream.IsPollableInputStream UnixInputStream
toUnixInputStream :: (MonadIO m, IsUnixInputStream o) => o -> m UnixInputStream
toUnixInputStream :: o -> m UnixInputStream
toUnixInputStream = IO UnixInputStream -> m UnixInputStream
forall (m :: * -> *) a. MonadIO m => IO a -> m a
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, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr UnixInputStream -> UnixInputStream
UnixInputStream
noUnixInputStream :: Maybe UnixInputStream
noUnixInputStream :: Maybe UnixInputStream
noUnixInputStream = Maybe UnixInputStream
forall a. Maybe a
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) => O.IsLabelProxy t (UnixInputStream -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveUnixInputStreamMethod t UnixInputStream, O.MethodInfo info UnixInputStream p) => O.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
#endif
getUnixInputStreamCloseFd :: (MonadIO m, IsUnixInputStream o) => o -> m Bool
getUnixInputStreamCloseFd :: o -> m Bool
getUnixInputStreamCloseFd obj :: o
obj = IO Bool -> m Bool
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
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
getObjectPropertyBool o
obj "close-fd"
setUnixInputStreamCloseFd :: (MonadIO m, IsUnixInputStream o) => o -> Bool -> m ()
setUnixInputStreamCloseFd :: o -> Bool -> m ()
setUnixInputStreamCloseFd obj :: o
obj val :: Bool
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ o -> String -> Bool -> IO ()
forall a. GObject a => a -> String -> Bool -> IO ()
setObjectPropertyBool o
obj "close-fd" Bool
val
constructUnixInputStreamCloseFd :: (IsUnixInputStream o) => Bool -> IO (GValueConstruct o)
constructUnixInputStreamCloseFd :: Bool -> IO (GValueConstruct o)
constructUnixInputStreamCloseFd val :: Bool
val = String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
constructObjectPropertyBool "close-fd" Bool
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
getUnixInputStreamFd :: (MonadIO m, IsUnixInputStream o) => o -> m Int32
getUnixInputStreamFd :: o -> m Int32
getUnixInputStreamFd obj :: o
obj = IO Int32 -> m Int32
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
$ o -> String -> IO Int32
forall a. GObject a => a -> String -> IO Int32
getObjectPropertyInt32 o
obj "fd"
constructUnixInputStreamFd :: (IsUnixInputStream o) => Int32 -> IO (GValueConstruct o)
constructUnixInputStreamFd :: Int32 -> IO (GValueConstruct o)
constructUnixInputStreamFd val :: Int32
val = String -> Int32 -> IO (GValueConstruct o)
forall o. String -> Int32 -> IO (GValueConstruct o)
constructObjectPropertyInt32 "fd" Int32
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
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 :: Int32 -> Bool -> m UnixInputStream
unixInputStreamNew fd :: Int32
fd closeFd :: Bool
closeFd = IO UnixInputStream -> m UnixInputStream
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
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
fromEnum) Bool
closeFd
Ptr UnixInputStream
result <- Int32 -> CInt -> IO (Ptr UnixInputStream)
g_unix_input_stream_new Int32
fd CInt
closeFd'
Text -> Ptr UnixInputStream -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "unixInputStreamNew" Ptr UnixInputStream
result
UnixInputStream
result' <- ((ManagedPtr UnixInputStream -> UnixInputStream)
-> Ptr UnixInputStream -> IO UnixInputStream
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr UnixInputStream -> UnixInputStream
UnixInputStream) Ptr UnixInputStream
result
UnixInputStream -> IO UnixInputStream
forall (m :: * -> *) a. Monad m => a -> m a
return UnixInputStream
result'
#if 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 :: a -> m Bool
unixInputStreamGetCloseFd stream :: a
stream = IO Bool -> m Bool
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
Ptr UnixInputStream
stream' <- a -> IO (Ptr UnixInputStream)
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' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if ENABLE_OVERLOADING
data UnixInputStreamGetCloseFdMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsUnixInputStream a) => O.MethodInfo UnixInputStreamGetCloseFdMethodInfo a signature where
overloadedMethod _ = 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 :: a -> m Int32
unixInputStreamGetFd stream :: a
stream = IO Int32 -> m Int32
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
Ptr UnixInputStream
stream' <- a -> IO (Ptr UnixInputStream)
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'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
#if ENABLE_OVERLOADING
data UnixInputStreamGetFdMethodInfo
instance (signature ~ (m Int32), MonadIO m, IsUnixInputStream a) => O.MethodInfo UnixInputStreamGetFdMethodInfo a signature where
overloadedMethod _ = 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 :: a -> Bool -> m ()
unixInputStreamSetCloseFd stream :: a
stream closeFd :: Bool
closeFd = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr UnixInputStream
stream' <- a -> IO (Ptr UnixInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
let closeFd' :: CInt
closeFd' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
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
fromEnum) Bool
closeFd
Ptr UnixInputStream -> CInt -> IO ()
g_unix_input_stream_set_close_fd Ptr UnixInputStream
stream' CInt
closeFd'
a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data UnixInputStreamSetCloseFdMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsUnixInputStream a) => O.MethodInfo UnixInputStreamSetCloseFdMethodInfo a signature where
overloadedMethod _ = unixInputStreamSetCloseFd
#endif