{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) A data structure representing an IO Channel. The fields should be considered private and should only be accessed with the following functions. -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.GLib.Structs.IOChannel ( -- * Exported types IOChannel(..) , newZeroIOChannel , noIOChannel , -- * Methods -- ** close #method:close# #if ENABLE_OVERLOADING IOChannelCloseMethodInfo , #endif iOChannelClose , -- ** errorFromErrno #method:errorFromErrno# iOChannelErrorFromErrno , -- ** errorQuark #method:errorQuark# iOChannelErrorQuark , -- ** flush #method:flush# #if ENABLE_OVERLOADING IOChannelFlushMethodInfo , #endif iOChannelFlush , -- ** getBufferCondition #method:getBufferCondition# #if ENABLE_OVERLOADING IOChannelGetBufferConditionMethodInfo , #endif iOChannelGetBufferCondition , -- ** getBufferSize #method:getBufferSize# #if ENABLE_OVERLOADING IOChannelGetBufferSizeMethodInfo , #endif iOChannelGetBufferSize , -- ** getBuffered #method:getBuffered# #if ENABLE_OVERLOADING IOChannelGetBufferedMethodInfo , #endif iOChannelGetBuffered , -- ** getCloseOnUnref #method:getCloseOnUnref# #if ENABLE_OVERLOADING IOChannelGetCloseOnUnrefMethodInfo , #endif iOChannelGetCloseOnUnref , -- ** getEncoding #method:getEncoding# #if ENABLE_OVERLOADING IOChannelGetEncodingMethodInfo , #endif iOChannelGetEncoding , -- ** getFlags #method:getFlags# #if ENABLE_OVERLOADING IOChannelGetFlagsMethodInfo , #endif iOChannelGetFlags , -- ** getLineTerm #method:getLineTerm# #if ENABLE_OVERLOADING IOChannelGetLineTermMethodInfo , #endif iOChannelGetLineTerm , -- ** init #method:init# #if ENABLE_OVERLOADING IOChannelInitMethodInfo , #endif iOChannelInit , -- ** newFile #method:newFile# iOChannelNewFile , -- ** read #method:read# #if ENABLE_OVERLOADING IOChannelReadMethodInfo , #endif iOChannelRead , -- ** readChars #method:readChars# #if ENABLE_OVERLOADING IOChannelReadCharsMethodInfo , #endif iOChannelReadChars , -- ** readLine #method:readLine# #if ENABLE_OVERLOADING IOChannelReadLineMethodInfo , #endif iOChannelReadLine , -- ** readToEnd #method:readToEnd# #if ENABLE_OVERLOADING IOChannelReadToEndMethodInfo , #endif iOChannelReadToEnd , -- ** readUnichar #method:readUnichar# #if ENABLE_OVERLOADING IOChannelReadUnicharMethodInfo , #endif iOChannelReadUnichar , -- ** ref #method:ref# #if ENABLE_OVERLOADING IOChannelRefMethodInfo , #endif iOChannelRef , -- ** seek #method:seek# #if ENABLE_OVERLOADING IOChannelSeekMethodInfo , #endif iOChannelSeek , -- ** seekPosition #method:seekPosition# #if ENABLE_OVERLOADING IOChannelSeekPositionMethodInfo , #endif iOChannelSeekPosition , -- ** setBufferSize #method:setBufferSize# #if ENABLE_OVERLOADING IOChannelSetBufferSizeMethodInfo , #endif iOChannelSetBufferSize , -- ** setBuffered #method:setBuffered# #if ENABLE_OVERLOADING IOChannelSetBufferedMethodInfo , #endif iOChannelSetBuffered , -- ** setCloseOnUnref #method:setCloseOnUnref# #if ENABLE_OVERLOADING IOChannelSetCloseOnUnrefMethodInfo , #endif iOChannelSetCloseOnUnref , -- ** setEncoding #method:setEncoding# #if ENABLE_OVERLOADING IOChannelSetEncodingMethodInfo , #endif iOChannelSetEncoding , -- ** setFlags #method:setFlags# #if ENABLE_OVERLOADING IOChannelSetFlagsMethodInfo , #endif iOChannelSetFlags , -- ** setLineTerm #method:setLineTerm# #if ENABLE_OVERLOADING IOChannelSetLineTermMethodInfo , #endif iOChannelSetLineTerm , -- ** shutdown #method:shutdown# #if ENABLE_OVERLOADING IOChannelShutdownMethodInfo , #endif iOChannelShutdown , -- ** unixGetFd #method:unixGetFd# #if ENABLE_OVERLOADING IOChannelUnixGetFdMethodInfo , #endif iOChannelUnixGetFd , -- ** unixNew #method:unixNew# iOChannelUnixNew , -- ** unref #method:unref# #if ENABLE_OVERLOADING IOChannelUnrefMethodInfo , #endif iOChannelUnref , -- ** write #method:write# #if ENABLE_OVERLOADING IOChannelWriteMethodInfo , #endif iOChannelWrite , -- ** writeChars #method:writeChars# #if ENABLE_OVERLOADING IOChannelWriteCharsMethodInfo , #endif iOChannelWriteChars , -- ** writeUnichar #method:writeUnichar# #if ENABLE_OVERLOADING IOChannelWriteUnicharMethodInfo , #endif iOChannelWriteUnichar , ) 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 {-# SOURCE #-} qualified GI.GLib.Enums as GLib.Enums import {-# SOURCE #-} qualified GI.GLib.Flags as GLib.Flags -- | Memory-managed wrapper type. newtype IOChannel = IOChannel (ManagedPtr IOChannel) foreign import ccall "g_io_channel_get_type" c_g_io_channel_get_type :: IO GType instance BoxedObject IOChannel where boxedType _ = c_g_io_channel_get_type -- | Construct a `IOChannel` struct initialized to zero. newZeroIOChannel :: MonadIO m => m IOChannel newZeroIOChannel = liftIO $ callocBoxedBytes 136 >>= wrapBoxed IOChannel instance tag ~ 'AttrSet => Constructible IOChannel tag where new _ attrs = do o <- newZeroIOChannel GI.Attributes.set o attrs return o -- | A convenience alias for `Nothing` :: `Maybe` `IOChannel`. noIOChannel :: Maybe IOChannel noIOChannel = Nothing #if ENABLE_OVERLOADING instance O.HasAttributeList IOChannel type instance O.AttributeList IOChannel = IOChannelAttributeList type IOChannelAttributeList = ('[ ] :: [(Symbol, *)]) #endif -- method IOChannel::new_file -- method type : Constructor -- Args : [Arg {argCName = "filename", argType = TBasicType TFileName, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A string containing the name of a file", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "One of \"r\", \"w\", \"a\", \"r+\", \"w+\", \"a+\". These have\n the same meaning as in fopen()", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOChannel"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_new_file" g_io_channel_new_file :: CString -> -- filename : TBasicType TFileName CString -> -- mode : TBasicType TUTF8 Ptr (Ptr GError) -> -- error IO (Ptr IOChannel) {- | Open a file /@filename@/ as a 'GI.GLib.Structs.IOChannel.IOChannel' using mode /@mode@/. This channel will be closed when the last reference to it is dropped, so there is no need to call 'GI.GLib.Structs.IOChannel.iOChannelClose' (though doing so will not cause problems, as long as no attempt is made to access the channel after it is closed). -} iOChannelNewFile :: (B.CallStack.HasCallStack, MonadIO m) => [Char] {- ^ /@filename@/: A string containing the name of a file -} -> T.Text {- ^ /@mode@/: One of \"r\", \"w\", \"a\", \"r+\", \"w+\", \"a+\". These have the same meaning as in @/fopen()/@ -} -> m IOChannel {- ^ __Returns:__ A 'GI.GLib.Structs.IOChannel.IOChannel' on success, 'Nothing' on failure. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelNewFile filename mode = liftIO $ do filename' <- stringToCString filename mode' <- textToCString mode onException (do result <- propagateGError $ g_io_channel_new_file filename' mode' checkUnexpectedReturnNULL "iOChannelNewFile" result result' <- (wrapBoxed IOChannel) result freeMem filename' freeMem mode' return result' ) (do freeMem filename' freeMem mode' ) #if ENABLE_OVERLOADING #endif -- method IOChannel::unix_new -- method type : Constructor -- Args : [Arg {argCName = "fd", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a file descriptor.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOChannel"})) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_unix_new" g_io_channel_unix_new :: Int32 -> -- fd : TBasicType TInt IO (Ptr IOChannel) {- | Creates a new 'GI.GLib.Structs.IOChannel.IOChannel' given a file descriptor. On UNIX systems this works for plain files, pipes, and sockets. The returned 'GI.GLib.Structs.IOChannel.IOChannel' has a reference count of 1. The default encoding for 'GI.GLib.Structs.IOChannel.IOChannel' is UTF-8. If your application is reading output from a command using via pipe, you may need to set the encoding to the encoding of the current locale (see 'GI.GLib.Functions.getCharset') with the 'GI.GLib.Structs.IOChannel.iOChannelSetEncoding' function. By default, the fd passed will not be closed when the final reference to the 'GI.GLib.Structs.IOChannel.IOChannel' data structure is dropped. If you want to read raw binary data without interpretation, then call the 'GI.GLib.Structs.IOChannel.iOChannelSetEncoding' function with 'Nothing' for the encoding argument. This function is available in GLib on Windows, too, but you should avoid using it on Windows. The domain of file descriptors and sockets overlap. There is no way for GLib to know which one you mean in case the argument you pass to this function happens to be both a valid file descriptor and socket. If that happens a warning is issued, and GLib assumes that it is the file descriptor you mean. -} iOChannelUnixNew :: (B.CallStack.HasCallStack, MonadIO m) => Int32 {- ^ /@fd@/: a file descriptor. -} -> m IOChannel {- ^ __Returns:__ a new 'GI.GLib.Structs.IOChannel.IOChannel'. -} iOChannelUnixNew fd = liftIO $ do result <- g_io_channel_unix_new fd checkUnexpectedReturnNULL "iOChannelUnixNew" result result' <- (wrapBoxed IOChannel) result return result' #if ENABLE_OVERLOADING #endif -- method IOChannel::close -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_io_channel_close" g_io_channel_close :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO () {-# DEPRECATED iOChannelClose ["(Since version 2.2)","Use 'GI.GLib.Structs.IOChannel.iOChannelShutdown' instead."] #-} {- | Close an IO channel. Any pending data to be written will be flushed, ignoring errors. The channel will not be freed until the last reference is dropped using 'GI.GLib.Structs.IOChannel.iOChannelUnref'. -} iOChannelClose :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: A 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m () iOChannelClose channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel g_io_channel_close channel' touchManagedPtr channel return () #if ENABLE_OVERLOADING data IOChannelCloseMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IOChannelCloseMethodInfo IOChannel signature where overloadedMethod _ = iOChannelClose #endif -- method IOChannel::flush -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_flush" g_io_channel_flush :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Ptr (Ptr GError) -> -- error IO CUInt {- | Flushes the write buffer for the GIOChannel. -} iOChannelFlush :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m GLib.Enums.IOStatus {- ^ __Returns:__ the status of the operation: One of @/G_IO_STATUS_NORMAL/@, @/G_IO_STATUS_AGAIN/@, or @/G_IO_STATUS_ERROR/@. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelFlush channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel onException (do result <- propagateGError $ g_io_channel_flush channel' let result' = (toEnum . fromIntegral) result touchManagedPtr channel return result' ) (do return () ) #if ENABLE_OVERLOADING data IOChannelFlushMethodInfo instance (signature ~ (m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelFlushMethodInfo IOChannel signature where overloadedMethod _ = iOChannelFlush #endif -- method IOChannel::get_buffer_condition -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "A #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOCondition"})) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_get_buffer_condition" g_io_channel_get_buffer_condition :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO CUInt {- | This function returns a 'GI.GLib.Flags.IOCondition' depending on whether there is data to be read\/space to write data in the internal buffers in the 'GI.GLib.Structs.IOChannel.IOChannel'. Only the flags 'GI.GLib.Flags.IOConditionIn' and 'GI.GLib.Flags.IOConditionOut' may be set. -} iOChannelGetBufferCondition :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: A 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m [GLib.Flags.IOCondition] {- ^ __Returns:__ A 'GI.GLib.Flags.IOCondition' -} iOChannelGetBufferCondition channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_get_buffer_condition channel' let result' = wordToGFlags result touchManagedPtr channel return result' #if ENABLE_OVERLOADING data IOChannelGetBufferConditionMethodInfo instance (signature ~ (m [GLib.Flags.IOCondition]), MonadIO m) => O.MethodInfo IOChannelGetBufferConditionMethodInfo IOChannel signature where overloadedMethod _ = iOChannelGetBufferCondition #endif -- method IOChannel::get_buffer_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUInt64) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_get_buffer_size" g_io_channel_get_buffer_size :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO Word64 {- | Gets the buffer size. -} iOChannelGetBufferSize :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m Word64 {- ^ __Returns:__ the size of the buffer. -} iOChannelGetBufferSize channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_get_buffer_size channel' touchManagedPtr channel return result #if ENABLE_OVERLOADING data IOChannelGetBufferSizeMethodInfo instance (signature ~ (m Word64), MonadIO m) => O.MethodInfo IOChannelGetBufferSizeMethodInfo IOChannel signature where overloadedMethod _ = iOChannelGetBufferSize #endif -- method IOChannel::get_buffered -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", 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_io_channel_get_buffered" g_io_channel_get_buffered :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO CInt {- | Returns whether /@channel@/ is buffered. -} iOChannelGetBuffered :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m Bool {- ^ __Returns:__ 'True' if the /@channel@/ is buffered. -} iOChannelGetBuffered channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_get_buffered channel' let result' = (/= 0) result touchManagedPtr channel return result' #if ENABLE_OVERLOADING data IOChannelGetBufferedMethodInfo instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo IOChannelGetBufferedMethodInfo IOChannel signature where overloadedMethod _ = iOChannelGetBuffered #endif -- method IOChannel::get_close_on_unref -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel.", 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_io_channel_get_close_on_unref" g_io_channel_get_close_on_unref :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO CInt {- | Returns whether the file\/socket\/whatever associated with /@channel@/ will be closed when /@channel@/ receives its final unref and is destroyed. The default value of this is 'True' for channels created by g_io_channel_new_file (), and 'False' for all other channels. -} iOChannelGetCloseOnUnref :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel'. -} -> m Bool {- ^ __Returns:__ 'True' if the channel will be closed, 'False' otherwise. -} iOChannelGetCloseOnUnref channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_get_close_on_unref channel' let result' = (/= 0) result touchManagedPtr channel return result' #if ENABLE_OVERLOADING data IOChannelGetCloseOnUnrefMethodInfo instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo IOChannelGetCloseOnUnrefMethodInfo IOChannel signature where overloadedMethod _ = iOChannelGetCloseOnUnref #endif -- method IOChannel::get_encoding -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_get_encoding" g_io_channel_get_encoding :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO CString {- | Gets the encoding for the input\/output of the channel. The internal encoding is always UTF-8. The encoding 'Nothing' makes the channel safe for binary data. -} iOChannelGetEncoding :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m T.Text {- ^ __Returns:__ A string containing the encoding, this string is owned by GLib and must not be freed. -} iOChannelGetEncoding channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_get_encoding channel' checkUnexpectedReturnNULL "iOChannelGetEncoding" result result' <- cstringToText result touchManagedPtr channel return result' #if ENABLE_OVERLOADING data IOChannelGetEncodingMethodInfo instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo IOChannelGetEncodingMethodInfo IOChannel signature where overloadedMethod _ = iOChannelGetEncoding #endif -- method IOChannel::get_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOFlags"})) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_get_flags" g_io_channel_get_flags :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO CUInt {- | Gets the current flags for a 'GI.GLib.Structs.IOChannel.IOChannel', including read-only flags such as 'GI.GLib.Flags.IOFlagsIsReadable'. The values of the flags 'GI.GLib.Flags.IOFlagsIsReadable' and 'GI.GLib.Flags.IOFlagsIsWritable' are cached for internal use by the channel when it is created. If they should change at some later point (e.g. partial shutdown of a socket with the UNIX @/shutdown()/@ function), the user should immediately call 'GI.GLib.Structs.IOChannel.iOChannelGetFlags' to update the internal values of these flags. -} iOChannelGetFlags :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m [GLib.Flags.IOFlags] {- ^ __Returns:__ the flags which are set on the channel -} iOChannelGetFlags channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_get_flags channel' let result' = wordToGFlags result touchManagedPtr channel return result' #if ENABLE_OVERLOADING data IOChannelGetFlagsMethodInfo instance (signature ~ (m [GLib.Flags.IOFlags]), MonadIO m) => O.MethodInfo IOChannelGetFlagsMethodInfo IOChannel signature where overloadedMethod _ = iOChannelGetFlags #endif -- method IOChannel::get_line_term -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to return the length of the line terminator", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TBasicType TUTF8) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_get_line_term" g_io_channel_get_line_term :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Int32 -> -- length : TBasicType TInt IO CString {- | This returns the string that 'GI.GLib.Structs.IOChannel.IOChannel' uses to determine where in the file a line break occurs. A value of 'Nothing' indicates autodetection. -} iOChannelGetLineTerm :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Int32 {- ^ /@length@/: a location to return the length of the line terminator -} -> m T.Text {- ^ __Returns:__ The line termination string. This value is owned by GLib and must not be freed. -} iOChannelGetLineTerm channel length_ = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_get_line_term channel' length_ checkUnexpectedReturnNULL "iOChannelGetLineTerm" result result' <- cstringToText result touchManagedPtr channel return result' #if ENABLE_OVERLOADING data IOChannelGetLineTermMethodInfo instance (signature ~ (Int32 -> m T.Text), MonadIO m) => O.MethodInfo IOChannelGetLineTermMethodInfo IOChannel signature where overloadedMethod _ = iOChannelGetLineTerm #endif -- method IOChannel::init -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_io_channel_init" g_io_channel_init :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO () {- | Initializes a 'GI.GLib.Structs.IOChannel.IOChannel' struct. This is called by each of the above functions when creating a 'GI.GLib.Structs.IOChannel.IOChannel', and so is not often needed by the application programmer (unless you are creating a new type of 'GI.GLib.Structs.IOChannel.IOChannel'). -} iOChannelInit :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m () iOChannelInit channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel g_io_channel_init channel' touchManagedPtr channel return () #if ENABLE_OVERLOADING data IOChannelInitMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IOChannelInitMethodInfo IOChannel signature where overloadedMethod _ = iOChannelInit #endif -- method IOChannel::read -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffer to read the data into (which should be at least\n count bytes long)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to read from the #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "returns the number of bytes actually read", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOError"})) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_read" g_io_channel_read :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CString -> -- buf : TBasicType TUTF8 Word64 -> -- count : TBasicType TUInt64 Word64 -> -- bytes_read : TBasicType TUInt64 IO CUInt {-# DEPRECATED iOChannelRead ["(Since version 2.2)","Use 'GI.GLib.Structs.IOChannel.iOChannelReadChars' instead."] #-} {- | Reads data from a 'GI.GLib.Structs.IOChannel.IOChannel'. -} iOChannelRead :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> T.Text {- ^ /@buf@/: a buffer to read the data into (which should be at least count bytes long) -} -> Word64 {- ^ /@count@/: the number of bytes to read from the 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Word64 {- ^ /@bytesRead@/: returns the number of bytes actually read -} -> m GLib.Enums.IOError {- ^ __Returns:__ 'GI.GLib.Enums.IOErrorNone' if the operation was successful. -} iOChannelRead channel buf count bytesRead = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel buf' <- textToCString buf result <- g_io_channel_read channel' buf' count bytesRead let result' = (toEnum . fromIntegral) result touchManagedPtr channel freeMem buf' return result' #if ENABLE_OVERLOADING data IOChannelReadMethodInfo instance (signature ~ (T.Text -> Word64 -> Word64 -> m GLib.Enums.IOError), MonadIO m) => O.MethodInfo IOChannelReadMethodInfo IOChannel signature where overloadedMethod _ = iOChannelRead #endif -- method IOChannel::read_chars -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "\n a buffer to read data into", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = True, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the buffer. Note that the buffer may not be\n complelely filled even if there is data in the buffer if the\n remaining data is not a complete character.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_read", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The number of bytes read. This may be\n zero even on success if count < 6 and the channel's encoding\n is non-%NULL. This indicates that the next UTF-8 character is\n too wide for the buffer.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the buffer. Note that the buffer may not be\n complelely filled even if there is data in the buffer if the\n remaining data is not a complete character.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_read_chars" g_io_channel_read_chars :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Ptr Word8 -> -- buf : TCArray False (-1) 2 (TBasicType TUInt8) Word64 -> -- count : TBasicType TUInt64 Ptr Word64 -> -- bytes_read : TBasicType TUInt64 Ptr (Ptr GError) -> -- error IO CUInt {- | Replacement for 'GI.GLib.Structs.IOChannel.iOChannelRead' with the new API. -} iOChannelReadChars :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> ByteString {- ^ /@buf@/: a buffer to read data into -} -> m ((GLib.Enums.IOStatus, ByteString, Word64)) {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelReadChars channel buf = liftIO $ do let count = fromIntegral $ B.length buf channel' <- unsafeManagedPtrGetPtr channel buf' <- packByteString buf bytesRead <- allocMem :: IO (Ptr Word64) onException (do result <- propagateGError $ g_io_channel_read_chars channel' buf' count bytesRead let result' = (toEnum . fromIntegral) result buf'' <- (unpackByteStringWithLength count) buf' bytesRead' <- peek bytesRead touchManagedPtr channel freeMem bytesRead return (result', buf'', bytesRead') ) (do freeMem buf' freeMem bytesRead ) #if ENABLE_OVERLOADING data IOChannelReadCharsMethodInfo instance (signature ~ (ByteString -> m ((GLib.Enums.IOStatus, ByteString, Word64))), MonadIO m) => O.MethodInfo IOChannelReadCharsMethodInfo IOChannel signature where overloadedMethod _ = iOChannelReadChars #endif -- method IOChannel::read_line -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str_return", argType = TBasicType TUTF8, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The line read from the #GIOChannel, including the\n line terminator. This data should be freed with g_free()\n when no longer needed. This is a nul-terminated string.\n If a @length of zero is returned, this will be %NULL instead.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store length of the read data, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "terminator_pos", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store position of line terminator, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_read_line" g_io_channel_read_line :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Ptr CString -> -- str_return : TBasicType TUTF8 Ptr Word64 -> -- length : TBasicType TUInt64 Ptr Word64 -> -- terminator_pos : TBasicType TUInt64 Ptr (Ptr GError) -> -- error IO CUInt {- | Reads a line, including the terminating character(s), from a 'GI.GLib.Structs.IOChannel.IOChannel' into a newly-allocated string. /@strReturn@/ will contain allocated memory if the return is 'GI.GLib.Enums.IOStatusNormal'. -} iOChannelReadLine :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m ((GLib.Enums.IOStatus, T.Text, Word64, Word64)) {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelReadLine channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel strReturn <- allocMem :: IO (Ptr CString) length_ <- allocMem :: IO (Ptr Word64) terminatorPos <- allocMem :: IO (Ptr Word64) onException (do result <- propagateGError $ g_io_channel_read_line channel' strReturn length_ terminatorPos let result' = (toEnum . fromIntegral) result strReturn' <- peek strReturn strReturn'' <- cstringToText strReturn' freeMem strReturn' length_' <- peek length_ terminatorPos' <- peek terminatorPos touchManagedPtr channel freeMem strReturn freeMem length_ freeMem terminatorPos return (result', strReturn'', length_', terminatorPos') ) (do freeMem strReturn freeMem length_ freeMem terminatorPos ) #if ENABLE_OVERLOADING data IOChannelReadLineMethodInfo instance (signature ~ (m ((GLib.Enums.IOStatus, T.Text, Word64, Word64))), MonadIO m) => O.MethodInfo IOChannelReadLineMethodInfo IOChannel signature where overloadedMethod _ = iOChannelReadLine #endif -- method IOChannel::read_to_end -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "str_return", argType = TCArray False (-1) 2 (TBasicType TUInt8), direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Location to\n store a pointer to a string holding the remaining data in the\n #GIOChannel. This data should be freed with g_free() when no\n longer needed. This data is terminated by an extra nul\n character, but there may be other nuls in the intervening data.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything},Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store length of the data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [Arg {argCName = "length", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "location to store length of the data", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_read_to_end" g_io_channel_read_to_end :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Ptr (Ptr Word8) -> -- str_return : TCArray False (-1) 2 (TBasicType TUInt8) Ptr Word64 -> -- length : TBasicType TUInt64 Ptr (Ptr GError) -> -- error IO CUInt {- | Reads all the remaining data from the file. -} iOChannelReadToEnd :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m ((GLib.Enums.IOStatus, ByteString)) {- ^ __Returns:__ 'GI.GLib.Enums.IOStatusNormal' on success. This function never returns 'GI.GLib.Enums.IOStatusEof'. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelReadToEnd channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel strReturn <- allocMem :: IO (Ptr (Ptr Word8)) length_ <- allocMem :: IO (Ptr Word64) onException (do result <- propagateGError $ g_io_channel_read_to_end channel' strReturn length_ length_' <- peek length_ let result' = (toEnum . fromIntegral) result strReturn' <- peek strReturn strReturn'' <- (unpackByteStringWithLength length_') strReturn' freeMem strReturn' touchManagedPtr channel freeMem strReturn freeMem length_ return (result', strReturn'') ) (do freeMem strReturn freeMem length_ ) #if ENABLE_OVERLOADING data IOChannelReadToEndMethodInfo instance (signature ~ (m ((GLib.Enums.IOStatus, ByteString))), MonadIO m) => O.MethodInfo IOChannelReadToEndMethodInfo IOChannel signature where overloadedMethod _ = iOChannelReadToEnd #endif -- method IOChannel::read_unichar -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "thechar", argType = TBasicType TUniChar, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a location to return a character", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_read_unichar" g_io_channel_read_unichar :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Ptr CInt -> -- thechar : TBasicType TUniChar Ptr (Ptr GError) -> -- error IO CUInt {- | Reads a Unicode character from /@channel@/. This function cannot be called on a channel with 'Nothing' encoding. -} iOChannelReadUnichar :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m ((GLib.Enums.IOStatus, Char)) {- ^ __Returns:__ a 'GI.GLib.Enums.IOStatus' /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelReadUnichar channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel thechar <- allocMem :: IO (Ptr CInt) onException (do result <- propagateGError $ g_io_channel_read_unichar channel' thechar let result' = (toEnum . fromIntegral) result thechar' <- peek thechar let thechar'' = (chr . fromIntegral) thechar' touchManagedPtr channel freeMem thechar return (result', thechar'') ) (do freeMem thechar ) #if ENABLE_OVERLOADING data IOChannelReadUnicharMethodInfo instance (signature ~ (m ((GLib.Enums.IOStatus, Char))), MonadIO m) => O.MethodInfo IOChannelReadUnicharMethodInfo IOChannel signature where overloadedMethod _ = iOChannelReadUnichar #endif -- method IOChannel::ref -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOChannel"})) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_ref" g_io_channel_ref :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO (Ptr IOChannel) {- | Increments the reference count of a 'GI.GLib.Structs.IOChannel.IOChannel'. -} iOChannelRef :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m IOChannel {- ^ __Returns:__ the /@channel@/ that was passed in (since 2.6) -} iOChannelRef channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_ref channel' checkUnexpectedReturnNULL "iOChannelRef" result result' <- (wrapBoxed IOChannel) result touchManagedPtr channel return result' #if ENABLE_OVERLOADING data IOChannelRefMethodInfo instance (signature ~ (m IOChannel), MonadIO m) => O.MethodInfo IOChannelRefMethodInfo IOChannel signature where overloadedMethod _ = iOChannelRef #endif -- method IOChannel::seek -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an offset, in bytes, which is added to the position specified\n by @type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "GLib", name = "SeekType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the position in the file, which can be %G_SEEK_CUR (the current\n position), %G_SEEK_SET (the start of the file), or %G_SEEK_END\n (the end of the file)", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOError"})) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_seek" g_io_channel_seek :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Int64 -> -- offset : TBasicType TInt64 CUInt -> -- type : TInterface (Name {namespace = "GLib", name = "SeekType"}) IO CUInt {-# DEPRECATED iOChannelSeek ["(Since version 2.2)","Use 'GI.GLib.Structs.IOChannel.iOChannelSeekPosition' instead."] #-} {- | Sets the current position in the 'GI.GLib.Structs.IOChannel.IOChannel', similar to the standard library function @/fseek()/@. -} iOChannelSeek :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Int64 {- ^ /@offset@/: an offset, in bytes, which is added to the position specified by /@type@/ -} -> GLib.Enums.SeekType {- ^ /@type@/: the position in the file, which can be 'GI.GLib.Enums.SeekTypeCur' (the current position), 'GI.GLib.Enums.SeekTypeSet' (the start of the file), or 'GI.GLib.Enums.SeekTypeEnd' (the end of the file) -} -> m GLib.Enums.IOError {- ^ __Returns:__ 'GI.GLib.Enums.IOErrorNone' if the operation was successful. -} iOChannelSeek channel offset type_ = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel let type_' = (fromIntegral . fromEnum) type_ result <- g_io_channel_seek channel' offset type_' let result' = (toEnum . fromIntegral) result touchManagedPtr channel return result' #if ENABLE_OVERLOADING data IOChannelSeekMethodInfo instance (signature ~ (Int64 -> GLib.Enums.SeekType -> m GLib.Enums.IOError), MonadIO m) => O.MethodInfo IOChannelSeekMethodInfo IOChannel signature where overloadedMethod _ = iOChannelSeek #endif -- method IOChannel::seek_position -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "offset", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The offset in bytes from the position specified by @type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "type", argType = TInterface (Name {namespace = "GLib", name = "SeekType"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSeekType. The type %G_SEEK_CUR is only allowed in those\n cases where a call to g_io_channel_set_encoding ()\n is allowed. See the documentation for\n g_io_channel_set_encoding () for details.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_seek_position" g_io_channel_seek_position :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Int64 -> -- offset : TBasicType TInt64 CUInt -> -- type : TInterface (Name {namespace = "GLib", name = "SeekType"}) Ptr (Ptr GError) -> -- error IO CUInt {- | Replacement for 'GI.GLib.Structs.IOChannel.iOChannelSeek' with the new API. -} iOChannelSeekPosition :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Int64 {- ^ /@offset@/: The offset in bytes from the position specified by /@type@/ -} -> GLib.Enums.SeekType {- ^ /@type@/: a 'GI.GLib.Enums.SeekType'. The type 'GI.GLib.Enums.SeekTypeCur' is only allowed in those cases where a call to g_io_channel_set_encoding () is allowed. See the documentation for g_io_channel_set_encoding () for details. -} -> m GLib.Enums.IOStatus {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelSeekPosition channel offset type_ = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel let type_' = (fromIntegral . fromEnum) type_ onException (do result <- propagateGError $ g_io_channel_seek_position channel' offset type_' let result' = (toEnum . fromIntegral) result touchManagedPtr channel return result' ) (do return () ) #if ENABLE_OVERLOADING data IOChannelSeekPositionMethodInfo instance (signature ~ (Int64 -> GLib.Enums.SeekType -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelSeekPositionMethodInfo IOChannel signature where overloadedMethod _ = iOChannelSeekPosition #endif -- method IOChannel::set_buffer_size -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "size", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the buffer, or 0 to let GLib pick a good size", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_io_channel_set_buffer_size" g_io_channel_set_buffer_size :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Word64 -> -- size : TBasicType TUInt64 IO () {- | Sets the buffer size. -} iOChannelSetBufferSize :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Word64 {- ^ /@size@/: the size of the buffer, or 0 to let GLib pick a good size -} -> m () iOChannelSetBufferSize channel size = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel g_io_channel_set_buffer_size channel' size touchManagedPtr channel return () #if ENABLE_OVERLOADING data IOChannelSetBufferSizeMethodInfo instance (signature ~ (Word64 -> m ()), MonadIO m) => O.MethodInfo IOChannelSetBufferSizeMethodInfo IOChannel signature where overloadedMethod _ = iOChannelSetBufferSize #endif -- method IOChannel::set_buffered -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buffered", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to set the channel buffered or unbuffered", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_io_channel_set_buffered" g_io_channel_set_buffered :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CInt -> -- buffered : TBasicType TBoolean IO () {- | The buffering state can only be set if the channel\'s encoding is 'Nothing'. For any other encoding, the channel must be buffered. A buffered channel can only be set unbuffered if the channel\'s internal buffers have been flushed. Newly created channels or channels which have returned 'GI.GLib.Enums.IOStatusEof' not require such a flush. For write-only channels, a call to g_io_channel_flush () is sufficient. For all other channels, the buffers may be flushed by a call to g_io_channel_seek_position (). This includes the possibility of seeking with seek type 'GI.GLib.Enums.SeekTypeCur' and an offset of zero. Note that this means that socket-based channels cannot be set unbuffered once they have had data read from them. On unbuffered channels, it is safe to mix read and write calls from the new and old APIs, if this is necessary for maintaining old code. The default state of the channel is buffered. -} iOChannelSetBuffered :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Bool {- ^ /@buffered@/: whether to set the channel buffered or unbuffered -} -> m () iOChannelSetBuffered channel buffered = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel let buffered' = (fromIntegral . fromEnum) buffered g_io_channel_set_buffered channel' buffered' touchManagedPtr channel return () #if ENABLE_OVERLOADING data IOChannelSetBufferedMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo IOChannelSetBufferedMethodInfo IOChannel signature where overloadedMethod _ = iOChannelSetBuffered #endif -- method IOChannel::set_close_on_unref -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "do_close", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "Whether to close the channel on the final unref of\n the GIOChannel data structure.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_io_channel_set_close_on_unref" g_io_channel_set_close_on_unref :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CInt -> -- do_close : TBasicType TBoolean IO () {- | Whether to close the channel on the final unref of the 'GI.GLib.Structs.IOChannel.IOChannel' data structure. The default value of this is 'True' for channels created by g_io_channel_new_file (), and 'False' for all other channels. Setting this flag to 'True' for a channel you have already closed can cause problems when the final reference to the 'GI.GLib.Structs.IOChannel.IOChannel' is dropped. -} iOChannelSetCloseOnUnref :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Bool {- ^ /@doClose@/: Whether to close the channel on the final unref of the GIOChannel data structure. -} -> m () iOChannelSetCloseOnUnref channel doClose = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel let doClose' = (fromIntegral . fromEnum) doClose g_io_channel_set_close_on_unref channel' doClose' touchManagedPtr channel return () #if ENABLE_OVERLOADING data IOChannelSetCloseOnUnrefMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m) => O.MethodInfo IOChannelSetCloseOnUnrefMethodInfo IOChannel signature where overloadedMethod _ = iOChannelSetCloseOnUnref #endif -- method IOChannel::set_encoding -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "encoding", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the encoding type", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_set_encoding" g_io_channel_set_encoding :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CString -> -- encoding : TBasicType TUTF8 Ptr (Ptr GError) -> -- error IO CUInt {- | Sets the encoding for the input\/output of the channel. The internal encoding is always UTF-8. The default encoding for the external file is UTF-8. The encoding 'Nothing' is safe to use with binary data. The encoding can only be set if one of the following conditions is true: * The channel was just created, and has not been written to or read from yet. * The channel is write-only. * The channel is a file, and the file pointer was just repositioned by a call to 'GI.GLib.Structs.IOChannel.iOChannelSeekPosition'. (This flushes all the internal buffers.) * The current encoding is 'Nothing' or UTF-8. * One of the (new API) read functions has just returned 'GI.GLib.Enums.IOStatusEof' (or, in the case of 'GI.GLib.Structs.IOChannel.iOChannelReadToEnd', 'GI.GLib.Enums.IOStatusNormal'). * One of the functions 'GI.GLib.Structs.IOChannel.iOChannelReadChars' or 'GI.GLib.Structs.IOChannel.iOChannelReadUnichar' has returned 'GI.GLib.Enums.IOStatusAgain' or 'GI.GLib.Enums.IOStatusError'. This may be useful in the case of 'GI.GLib.Enums.ConvertErrorIllegalSequence'. Returning one of these statuses from 'GI.GLib.Structs.IOChannel.iOChannelReadLine', @/g_io_channel_read_line_string()/@, or 'GI.GLib.Structs.IOChannel.iOChannelReadToEnd' does not guarantee that the encoding can be changed. Channels which do not meet one of the above conditions cannot call 'GI.GLib.Structs.IOChannel.iOChannelSeekPosition' with an offset of 'GI.GLib.Enums.SeekTypeCur', and, if they are \"seekable\", cannot call 'GI.GLib.Structs.IOChannel.iOChannelWriteChars' after calling one of the API \"read\" functions. -} iOChannelSetEncoding :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Maybe (T.Text) {- ^ /@encoding@/: the encoding type -} -> m GLib.Enums.IOStatus {- ^ __Returns:__ 'GI.GLib.Enums.IOStatusNormal' if the encoding was successfully set /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelSetEncoding channel encoding = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel maybeEncoding <- case encoding of Nothing -> return nullPtr Just jEncoding -> do jEncoding' <- textToCString jEncoding return jEncoding' onException (do result <- propagateGError $ g_io_channel_set_encoding channel' maybeEncoding let result' = (toEnum . fromIntegral) result touchManagedPtr channel freeMem maybeEncoding return result' ) (do freeMem maybeEncoding ) #if ENABLE_OVERLOADING data IOChannelSetEncodingMethodInfo instance (signature ~ (Maybe (T.Text) -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelSetEncodingMethodInfo IOChannel signature where overloadedMethod _ = iOChannelSetEncoding #endif -- method IOChannel::set_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "GLib", name = "IOFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the flags to set on the IO channel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_set_flags" g_io_channel_set_flags :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CUInt -> -- flags : TInterface (Name {namespace = "GLib", name = "IOFlags"}) Ptr (Ptr GError) -> -- error IO CUInt {- | Sets the (writeable) flags in /@channel@/ to (/@flags@/ & 'GI.GLib.Flags.IOFlagsSetMask'). -} iOChannelSetFlags :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> [GLib.Flags.IOFlags] {- ^ /@flags@/: the flags to set on the IO channel -} -> m GLib.Enums.IOStatus {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelSetFlags channel flags = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel let flags' = gflagsToWord flags onException (do result <- propagateGError $ g_io_channel_set_flags channel' flags' let result' = (toEnum . fromIntegral) result touchManagedPtr channel return result' ) (do return () ) #if ENABLE_OVERLOADING data IOChannelSetFlagsMethodInfo instance (signature ~ ([GLib.Flags.IOFlags] -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelSetFlagsMethodInfo IOChannel signature where overloadedMethod _ = iOChannelSetFlags #endif -- method IOChannel::set_line_term -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "line_term", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "The line termination string. Use %NULL for\n autodetect. Autodetection breaks on \"\\n\", \"\\r\\n\", \"\\r\", \"\\0\",\n and the Unicode paragraph separator. Autodetection should not be\n used for anything other than file-based channels.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "length", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The length of the termination string. If -1 is passed, the\n string is assumed to be nul-terminated. This option allows\n termination strings with embedded nuls.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_io_channel_set_line_term" g_io_channel_set_line_term :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CString -> -- line_term : TBasicType TUTF8 Int32 -> -- length : TBasicType TInt IO () {- | This sets the string that 'GI.GLib.Structs.IOChannel.IOChannel' uses to determine where in the file a line break occurs. -} iOChannelSetLineTerm :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Maybe (T.Text) {- ^ /@lineTerm@/: The line termination string. Use 'Nothing' for autodetect. Autodetection breaks on \"\\n\", \"\\r\\n\", \"\\r\", \"\\0\", and the Unicode paragraph separator. Autodetection should not be used for anything other than file-based channels. -} -> Int32 {- ^ /@length@/: The length of the termination string. If -1 is passed, the string is assumed to be nul-terminated. This option allows termination strings with embedded nuls. -} -> m () iOChannelSetLineTerm channel lineTerm length_ = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel maybeLineTerm <- case lineTerm of Nothing -> return nullPtr Just jLineTerm -> do jLineTerm' <- textToCString jLineTerm return jLineTerm' g_io_channel_set_line_term channel' maybeLineTerm length_ touchManagedPtr channel freeMem maybeLineTerm return () #if ENABLE_OVERLOADING data IOChannelSetLineTermMethodInfo instance (signature ~ (Maybe (T.Text) -> Int32 -> m ()), MonadIO m) => O.MethodInfo IOChannelSetLineTermMethodInfo IOChannel signature where overloadedMethod _ = iOChannelSetLineTerm #endif -- method IOChannel::shutdown -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flush", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "if %TRUE, flush pending", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_shutdown" g_io_channel_shutdown :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CInt -> -- flush : TBasicType TBoolean Ptr (Ptr GError) -> -- error IO CUInt {- | Close an IO channel. Any pending data to be written will be flushed if /@flush@/ is 'True'. The channel will not be freed until the last reference is dropped using 'GI.GLib.Structs.IOChannel.iOChannelUnref'. -} iOChannelShutdown :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Bool {- ^ /@flush@/: if 'True', flush pending -} -> m GLib.Enums.IOStatus {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelShutdown channel flush = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel let flush' = (fromIntegral . fromEnum) flush onException (do result <- propagateGError $ g_io_channel_shutdown channel' flush' let result' = (toEnum . fromIntegral) result touchManagedPtr channel return result' ) (do return () ) #if ENABLE_OVERLOADING data IOChannelShutdownMethodInfo instance (signature ~ (Bool -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelShutdownMethodInfo IOChannel signature where overloadedMethod _ = iOChannelShutdown #endif -- method IOChannel::unix_get_fd -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel, created with g_io_channel_unix_new().", 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_io_channel_unix_get_fd" g_io_channel_unix_get_fd :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO Int32 {- | Returns the file descriptor of the 'GI.GLib.Structs.IOChannel.IOChannel'. On Windows this function returns the file descriptor or socket of the 'GI.GLib.Structs.IOChannel.IOChannel'. -} iOChannelUnixGetFd :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel', created with 'GI.GLib.Structs.IOChannel.iOChannelUnixNew'. -} -> m Int32 {- ^ __Returns:__ the file descriptor of the 'GI.GLib.Structs.IOChannel.IOChannel'. -} iOChannelUnixGetFd channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel result <- g_io_channel_unix_get_fd channel' touchManagedPtr channel return result #if ENABLE_OVERLOADING data IOChannelUnixGetFdMethodInfo instance (signature ~ (m Int32), MonadIO m) => O.MethodInfo IOChannelUnixGetFdMethodInfo IOChannel signature where overloadedMethod _ = iOChannelUnixGetFd #endif -- method IOChannel::unref -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_io_channel_unref" g_io_channel_unref :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) IO () {- | Decrements the reference count of a 'GI.GLib.Structs.IOChannel.IOChannel'. -} iOChannelUnref :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> m () iOChannelUnref channel = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel g_io_channel_unref channel' touchManagedPtr channel return () #if ENABLE_OVERLOADING data IOChannelUnrefMethodInfo instance (signature ~ (m ()), MonadIO m) => O.MethodInfo IOChannelUnrefMethodInfo IOChannel signature where overloadedMethod _ = iOChannelUnref #endif -- method IOChannel::write -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TBasicType TUTF8, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the buffer containing the data to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes to write", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the number of bytes actually written", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOError"})) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_write" g_io_channel_write :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CString -> -- buf : TBasicType TUTF8 Word64 -> -- count : TBasicType TUInt64 Word64 -> -- bytes_written : TBasicType TUInt64 IO CUInt {-# DEPRECATED iOChannelWrite ["(Since version 2.2)","Use 'GI.GLib.Structs.IOChannel.iOChannelWriteChars' instead."] #-} {- | Writes data to a 'GI.GLib.Structs.IOChannel.IOChannel'. -} iOChannelWrite :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> T.Text {- ^ /@buf@/: the buffer containing the data to write -} -> Word64 {- ^ /@count@/: the number of bytes to write -} -> Word64 {- ^ /@bytesWritten@/: the number of bytes actually written -} -> m GLib.Enums.IOError {- ^ __Returns:__ 'GI.GLib.Enums.IOErrorNone' if the operation was successful. -} iOChannelWrite channel buf count bytesWritten = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel buf' <- textToCString buf result <- g_io_channel_write channel' buf' count bytesWritten let result' = (toEnum . fromIntegral) result touchManagedPtr channel freeMem buf' return result' #if ENABLE_OVERLOADING data IOChannelWriteMethodInfo instance (signature ~ (T.Text -> Word64 -> Word64 -> m GLib.Enums.IOError), MonadIO m) => O.MethodInfo IOChannelWriteMethodInfo IOChannel signature where overloadedMethod _ = iOChannelWrite #endif -- method IOChannel::write_chars -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "buf", argType = TCArray False (-1) (-1) (TBasicType TUInt8), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a buffer to write data from", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "count", argType = TBasicType TInt64, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the size of the buffer. If -1, the buffer\n is taken to be a nul-terminated string.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "bytes_written", argType = TBasicType TUInt64, direction = DirectionOut, mayBeNull = False, argDoc = Documentation {rawDocText = Just "The number of bytes written. This can be nonzero\n even if the return value is not %G_IO_STATUS_NORMAL.\n If the return value is %G_IO_STATUS_NORMAL and the\n channel is blocking, this will always be equal\n to @count if @count >= 0.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferEverything}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_write_chars" g_io_channel_write_chars :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) Ptr Word8 -> -- buf : TCArray False (-1) (-1) (TBasicType TUInt8) Int64 -> -- count : TBasicType TInt64 Ptr Word64 -> -- bytes_written : TBasicType TUInt64 Ptr (Ptr GError) -> -- error IO CUInt {- | Replacement for 'GI.GLib.Structs.IOChannel.iOChannelWrite' with the new API. On seekable channels with encodings other than 'Nothing' or UTF-8, generic mixing of reading and writing is not allowed. A call to g_io_channel_write_chars () may only be made on a channel from which data has been read in the cases described in the documentation for g_io_channel_set_encoding (). -} iOChannelWriteChars :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Ptr Word8 {- ^ /@buf@/: a buffer to write data from -} -> Int64 {- ^ /@count@/: the size of the buffer. If -1, the buffer is taken to be a nul-terminated string. -} -> m ((GLib.Enums.IOStatus, Word64)) {- ^ __Returns:__ the status of the operation. /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelWriteChars channel buf count = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel bytesWritten <- allocMem :: IO (Ptr Word64) onException (do result <- propagateGError $ g_io_channel_write_chars channel' buf count bytesWritten let result' = (toEnum . fromIntegral) result bytesWritten' <- peek bytesWritten touchManagedPtr channel freeMem bytesWritten return (result', bytesWritten') ) (do freeMem bytesWritten ) #if ENABLE_OVERLOADING data IOChannelWriteCharsMethodInfo instance (signature ~ (Ptr Word8 -> Int64 -> m ((GLib.Enums.IOStatus, Word64))), MonadIO m) => O.MethodInfo IOChannelWriteCharsMethodInfo IOChannel signature where overloadedMethod _ = iOChannelWriteChars #endif -- method IOChannel::write_unichar -- method type : OrdinaryMethod -- Args : [Arg {argCName = "channel", argType = TInterface (Name {namespace = "GLib", name = "IOChannel"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GIOChannel", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "thechar", argType = TBasicType TUniChar, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a character", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOStatus"})) -- throws : True -- Skip return : False foreign import ccall "g_io_channel_write_unichar" g_io_channel_write_unichar :: Ptr IOChannel -> -- channel : TInterface (Name {namespace = "GLib", name = "IOChannel"}) CInt -> -- thechar : TBasicType TUniChar Ptr (Ptr GError) -> -- error IO CUInt {- | Writes a Unicode character to /@channel@/. This function cannot be called on a channel with 'Nothing' encoding. -} iOChannelWriteUnichar :: (B.CallStack.HasCallStack, MonadIO m) => IOChannel {- ^ /@channel@/: a 'GI.GLib.Structs.IOChannel.IOChannel' -} -> Char {- ^ /@thechar@/: a character -} -> m GLib.Enums.IOStatus {- ^ __Returns:__ a 'GI.GLib.Enums.IOStatus' /(Can throw 'Data.GI.Base.GError.GError')/ -} iOChannelWriteUnichar channel thechar = liftIO $ do channel' <- unsafeManagedPtrGetPtr channel let thechar' = (fromIntegral . ord) thechar onException (do result <- propagateGError $ g_io_channel_write_unichar channel' thechar' let result' = (toEnum . fromIntegral) result touchManagedPtr channel return result' ) (do return () ) #if ENABLE_OVERLOADING data IOChannelWriteUnicharMethodInfo instance (signature ~ (Char -> m GLib.Enums.IOStatus), MonadIO m) => O.MethodInfo IOChannelWriteUnicharMethodInfo IOChannel signature where overloadedMethod _ = iOChannelWriteUnichar #endif -- method IOChannel::error_from_errno -- method type : MemberFunction -- Args : [Arg {argCName = "en", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "an `errno` error number, e.g. `EINVAL`", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "GLib", name = "IOChannelError"})) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_error_from_errno" g_io_channel_error_from_errno :: Int32 -> -- en : TBasicType TInt IO CUInt {- | Converts an @errno@ error number to a 'GI.GLib.Enums.IOChannelError'. -} iOChannelErrorFromErrno :: (B.CallStack.HasCallStack, MonadIO m) => Int32 {- ^ /@en@/: an @errno@ error number, e.g. @EINVAL@ -} -> m GLib.Enums.IOChannelError {- ^ __Returns:__ a 'GI.GLib.Enums.IOChannelError' error number, e.g. 'GI.GLib.Enums.IOChannelErrorInval'. -} iOChannelErrorFromErrno en = liftIO $ do result <- g_io_channel_error_from_errno en let result' = (toEnum . fromIntegral) result return result' #if ENABLE_OVERLOADING #endif -- method IOChannel::error_quark -- method type : MemberFunction -- Args : [] -- Lengths : [] -- returnType : Just (TBasicType TUInt32) -- throws : False -- Skip return : False foreign import ccall "g_io_channel_error_quark" g_io_channel_error_quark :: IO Word32 {- | /No description available in the introspection data./ -} iOChannelErrorQuark :: (B.CallStack.HasCallStack, MonadIO m) => m Word32 iOChannelErrorQuark = liftIO $ do result <- g_io_channel_error_quark return result #if ENABLE_OVERLOADING #endif #if ENABLE_OVERLOADING type family ResolveIOChannelMethod (t :: Symbol) (o :: *) :: * where ResolveIOChannelMethod "close" o = IOChannelCloseMethodInfo ResolveIOChannelMethod "flush" o = IOChannelFlushMethodInfo ResolveIOChannelMethod "init" o = IOChannelInitMethodInfo ResolveIOChannelMethod "read" o = IOChannelReadMethodInfo ResolveIOChannelMethod "readChars" o = IOChannelReadCharsMethodInfo ResolveIOChannelMethod "readLine" o = IOChannelReadLineMethodInfo ResolveIOChannelMethod "readToEnd" o = IOChannelReadToEndMethodInfo ResolveIOChannelMethod "readUnichar" o = IOChannelReadUnicharMethodInfo ResolveIOChannelMethod "ref" o = IOChannelRefMethodInfo ResolveIOChannelMethod "seek" o = IOChannelSeekMethodInfo ResolveIOChannelMethod "seekPosition" o = IOChannelSeekPositionMethodInfo ResolveIOChannelMethod "shutdown" o = IOChannelShutdownMethodInfo ResolveIOChannelMethod "unixGetFd" o = IOChannelUnixGetFdMethodInfo ResolveIOChannelMethod "unref" o = IOChannelUnrefMethodInfo ResolveIOChannelMethod "write" o = IOChannelWriteMethodInfo ResolveIOChannelMethod "writeChars" o = IOChannelWriteCharsMethodInfo ResolveIOChannelMethod "writeUnichar" o = IOChannelWriteUnicharMethodInfo ResolveIOChannelMethod "getBufferCondition" o = IOChannelGetBufferConditionMethodInfo ResolveIOChannelMethod "getBufferSize" o = IOChannelGetBufferSizeMethodInfo ResolveIOChannelMethod "getBuffered" o = IOChannelGetBufferedMethodInfo ResolveIOChannelMethod "getCloseOnUnref" o = IOChannelGetCloseOnUnrefMethodInfo ResolveIOChannelMethod "getEncoding" o = IOChannelGetEncodingMethodInfo ResolveIOChannelMethod "getFlags" o = IOChannelGetFlagsMethodInfo ResolveIOChannelMethod "getLineTerm" o = IOChannelGetLineTermMethodInfo ResolveIOChannelMethod "setBufferSize" o = IOChannelSetBufferSizeMethodInfo ResolveIOChannelMethod "setBuffered" o = IOChannelSetBufferedMethodInfo ResolveIOChannelMethod "setCloseOnUnref" o = IOChannelSetCloseOnUnrefMethodInfo ResolveIOChannelMethod "setEncoding" o = IOChannelSetEncodingMethodInfo ResolveIOChannelMethod "setFlags" o = IOChannelSetFlagsMethodInfo ResolveIOChannelMethod "setLineTerm" o = IOChannelSetLineTermMethodInfo ResolveIOChannelMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveIOChannelMethod t IOChannel, O.MethodInfo info IOChannel p) => OL.IsLabel t (IOChannel -> 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