{- | 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 @\@ 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 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 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 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