{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.DataInputStream
(
DataInputStream(..) ,
IsDataInputStream ,
toDataInputStream ,
#if defined(ENABLE_OVERLOADING)
ResolveDataInputStreamMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DataInputStreamGetByteOrderMethodInfo ,
#endif
dataInputStreamGetByteOrder ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamGetNewlineTypeMethodInfo ,
#endif
dataInputStreamGetNewlineType ,
dataInputStreamNew ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadByteMethodInfo ,
#endif
dataInputStreamReadByte ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadInt16MethodInfo ,
#endif
dataInputStreamReadInt16 ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadInt32MethodInfo ,
#endif
dataInputStreamReadInt32 ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadInt64MethodInfo ,
#endif
dataInputStreamReadInt64 ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadLineMethodInfo ,
#endif
dataInputStreamReadLine ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadLineAsyncMethodInfo ,
#endif
dataInputStreamReadLineAsync ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadLineFinishMethodInfo ,
#endif
dataInputStreamReadLineFinish ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadLineFinishUtf8MethodInfo,
#endif
dataInputStreamReadLineFinishUtf8 ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadLineUtf8MethodInfo ,
#endif
dataInputStreamReadLineUtf8 ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUint16MethodInfo ,
#endif
dataInputStreamReadUint16 ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUint32MethodInfo ,
#endif
dataInputStreamReadUint32 ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUint64MethodInfo ,
#endif
dataInputStreamReadUint64 ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUntilMethodInfo ,
#endif
dataInputStreamReadUntil ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUntilAsyncMethodInfo ,
#endif
dataInputStreamReadUntilAsync ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUntilFinishMethodInfo,
#endif
dataInputStreamReadUntilFinish ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUptoMethodInfo ,
#endif
dataInputStreamReadUpto ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUptoAsyncMethodInfo ,
#endif
dataInputStreamReadUptoAsync ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamReadUptoFinishMethodInfo ,
#endif
dataInputStreamReadUptoFinish ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamSetByteOrderMethodInfo ,
#endif
dataInputStreamSetByteOrder ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamSetNewlineTypeMethodInfo ,
#endif
dataInputStreamSetNewlineType ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamByteOrderPropertyInfo ,
#endif
constructDataInputStreamByteOrder ,
#if defined(ENABLE_OVERLOADING)
dataInputStreamByteOrder ,
#endif
getDataInputStreamByteOrder ,
setDataInputStreamByteOrder ,
#if defined(ENABLE_OVERLOADING)
DataInputStreamNewlineTypePropertyInfo ,
#endif
constructDataInputStreamNewlineType ,
#if defined(ENABLE_OVERLOADING)
dataInputStreamNewlineType ,
#endif
getDataInputStreamNewlineType ,
setDataInputStreamNewlineType ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified Data.Word as DW
import qualified Data.Int as DI
import qualified System.Posix.Types as SPT
import qualified Foreign.C.Types as FCT
#if MIN_VERSION_base(4,18,0)
import qualified GI.GLib.Callbacks as GLib.Callbacks
import qualified GI.GLib.Enums as GLib.Enums
import qualified GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GLib.Structs.PollFD as GLib.PollFD
import qualified GI.GLib.Structs.Source as GLib.Source
import qualified GI.GObject.Callbacks as GObject.Callbacks
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Seekable as Gio.Seekable
import {-# SOURCE #-} qualified GI.Gio.Objects.BufferedInputStream as Gio.BufferedInputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.FilterInputStream as Gio.FilterInputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
#else
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Interfaces.Seekable as Gio.Seekable
import {-# SOURCE #-} qualified GI.Gio.Objects.BufferedInputStream as Gio.BufferedInputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.FilterInputStream as Gio.FilterInputStream
import {-# SOURCE #-} qualified GI.Gio.Objects.InputStream as Gio.InputStream
#endif
newtype DataInputStream = DataInputStream (SP.ManagedPtr DataInputStream)
deriving (DataInputStream -> DataInputStream -> Bool
(DataInputStream -> DataInputStream -> Bool)
-> (DataInputStream -> DataInputStream -> Bool)
-> Eq DataInputStream
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DataInputStream -> DataInputStream -> Bool
== :: DataInputStream -> DataInputStream -> Bool
$c/= :: DataInputStream -> DataInputStream -> Bool
/= :: DataInputStream -> DataInputStream -> Bool
Eq)
instance SP.ManagedPtrNewtype DataInputStream where
toManagedPtr :: DataInputStream -> ManagedPtr DataInputStream
toManagedPtr (DataInputStream ManagedPtr DataInputStream
p) = ManagedPtr DataInputStream
p
foreign import ccall "g_data_input_stream_get_type"
c_g_data_input_stream_get_type :: IO B.Types.GType
instance B.Types.TypedObject DataInputStream where
glibType :: IO GType
glibType = IO GType
c_g_data_input_stream_get_type
instance B.Types.GObject DataInputStream
class (SP.GObject o, O.IsDescendantOf DataInputStream o) => IsDataInputStream o
instance (SP.GObject o, O.IsDescendantOf DataInputStream o) => IsDataInputStream o
instance O.HasParentTypes DataInputStream
type instance O.ParentTypes DataInputStream = '[Gio.BufferedInputStream.BufferedInputStream, Gio.FilterInputStream.FilterInputStream, Gio.InputStream.InputStream, GObject.Object.Object, Gio.Seekable.Seekable]
toDataInputStream :: (MIO.MonadIO m, IsDataInputStream o) => o -> m DataInputStream
toDataInputStream :: forall (m :: * -> *) o.
(MonadIO m, IsDataInputStream o) =>
o -> m DataInputStream
toDataInputStream = IO DataInputStream -> m DataInputStream
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DataInputStream -> m DataInputStream)
-> (o -> IO DataInputStream) -> o -> m DataInputStream
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr DataInputStream -> DataInputStream)
-> o -> IO DataInputStream
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr DataInputStream -> DataInputStream
DataInputStream
instance B.GValue.IsGValue (Maybe DataInputStream) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_data_input_stream_get_type
gvalueSet_ :: Ptr GValue -> Maybe DataInputStream -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DataInputStream
P.Nothing = Ptr GValue -> Ptr DataInputStream -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr DataInputStream
forall a. Ptr a
FP.nullPtr :: FP.Ptr DataInputStream)
gvalueSet_ Ptr GValue
gv (P.Just DataInputStream
obj) = DataInputStream -> (Ptr DataInputStream -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DataInputStream
obj (Ptr GValue -> Ptr DataInputStream -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DataInputStream)
gvalueGet_ Ptr GValue
gv = do
ptr <- Ptr GValue -> IO (Ptr DataInputStream)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr DataInputStream)
if ptr /= FP.nullPtr
then P.Just <$> B.ManagedPtr.newObject DataInputStream ptr
else return P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveDataInputStreamMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveDataInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDataInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDataInputStreamMethod "canSeek" o = Gio.Seekable.SeekableCanSeekMethodInfo
ResolveDataInputStreamMethod "canTruncate" o = Gio.Seekable.SeekableCanTruncateMethodInfo
ResolveDataInputStreamMethod "clearPending" o = Gio.InputStream.InputStreamClearPendingMethodInfo
ResolveDataInputStreamMethod "close" o = Gio.InputStream.InputStreamCloseMethodInfo
ResolveDataInputStreamMethod "closeAsync" o = Gio.InputStream.InputStreamCloseAsyncMethodInfo
ResolveDataInputStreamMethod "closeFinish" o = Gio.InputStream.InputStreamCloseFinishMethodInfo
ResolveDataInputStreamMethod "fill" o = Gio.BufferedInputStream.BufferedInputStreamFillMethodInfo
ResolveDataInputStreamMethod "fillAsync" o = Gio.BufferedInputStream.BufferedInputStreamFillAsyncMethodInfo
ResolveDataInputStreamMethod "fillFinish" o = Gio.BufferedInputStream.BufferedInputStreamFillFinishMethodInfo
ResolveDataInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDataInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDataInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDataInputStreamMethod "hasPending" o = Gio.InputStream.InputStreamHasPendingMethodInfo
ResolveDataInputStreamMethod "isClosed" o = Gio.InputStream.InputStreamIsClosedMethodInfo
ResolveDataInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDataInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDataInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDataInputStreamMethod "peek" o = Gio.BufferedInputStream.BufferedInputStreamPeekMethodInfo
ResolveDataInputStreamMethod "peekBuffer" o = Gio.BufferedInputStream.BufferedInputStreamPeekBufferMethodInfo
ResolveDataInputStreamMethod "read" o = Gio.InputStream.InputStreamReadMethodInfo
ResolveDataInputStreamMethod "readAll" o = Gio.InputStream.InputStreamReadAllMethodInfo
ResolveDataInputStreamMethod "readAllAsync" o = Gio.InputStream.InputStreamReadAllAsyncMethodInfo
ResolveDataInputStreamMethod "readAllFinish" o = Gio.InputStream.InputStreamReadAllFinishMethodInfo
ResolveDataInputStreamMethod "readAsync" o = Gio.InputStream.InputStreamReadAsyncMethodInfo
ResolveDataInputStreamMethod "readByte" o = DataInputStreamReadByteMethodInfo
ResolveDataInputStreamMethod "readBytes" o = Gio.InputStream.InputStreamReadBytesMethodInfo
ResolveDataInputStreamMethod "readBytesAsync" o = Gio.InputStream.InputStreamReadBytesAsyncMethodInfo
ResolveDataInputStreamMethod "readBytesFinish" o = Gio.InputStream.InputStreamReadBytesFinishMethodInfo
ResolveDataInputStreamMethod "readFinish" o = Gio.InputStream.InputStreamReadFinishMethodInfo
ResolveDataInputStreamMethod "readInt16" o = DataInputStreamReadInt16MethodInfo
ResolveDataInputStreamMethod "readInt32" o = DataInputStreamReadInt32MethodInfo
ResolveDataInputStreamMethod "readInt64" o = DataInputStreamReadInt64MethodInfo
ResolveDataInputStreamMethod "readLine" o = DataInputStreamReadLineMethodInfo
ResolveDataInputStreamMethod "readLineAsync" o = DataInputStreamReadLineAsyncMethodInfo
ResolveDataInputStreamMethod "readLineFinish" o = DataInputStreamReadLineFinishMethodInfo
ResolveDataInputStreamMethod "readLineFinishUtf8" o = DataInputStreamReadLineFinishUtf8MethodInfo
ResolveDataInputStreamMethod "readLineUtf8" o = DataInputStreamReadLineUtf8MethodInfo
ResolveDataInputStreamMethod "readUint16" o = DataInputStreamReadUint16MethodInfo
ResolveDataInputStreamMethod "readUint32" o = DataInputStreamReadUint32MethodInfo
ResolveDataInputStreamMethod "readUint64" o = DataInputStreamReadUint64MethodInfo
ResolveDataInputStreamMethod "readUntil" o = DataInputStreamReadUntilMethodInfo
ResolveDataInputStreamMethod "readUntilAsync" o = DataInputStreamReadUntilAsyncMethodInfo
ResolveDataInputStreamMethod "readUntilFinish" o = DataInputStreamReadUntilFinishMethodInfo
ResolveDataInputStreamMethod "readUpto" o = DataInputStreamReadUptoMethodInfo
ResolveDataInputStreamMethod "readUptoAsync" o = DataInputStreamReadUptoAsyncMethodInfo
ResolveDataInputStreamMethod "readUptoFinish" o = DataInputStreamReadUptoFinishMethodInfo
ResolveDataInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDataInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDataInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDataInputStreamMethod "seek" o = Gio.Seekable.SeekableSeekMethodInfo
ResolveDataInputStreamMethod "skip" o = Gio.InputStream.InputStreamSkipMethodInfo
ResolveDataInputStreamMethod "skipAsync" o = Gio.InputStream.InputStreamSkipAsyncMethodInfo
ResolveDataInputStreamMethod "skipFinish" o = Gio.InputStream.InputStreamSkipFinishMethodInfo
ResolveDataInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDataInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDataInputStreamMethod "tell" o = Gio.Seekable.SeekableTellMethodInfo
ResolveDataInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDataInputStreamMethod "truncate" o = Gio.Seekable.SeekableTruncateMethodInfo
ResolveDataInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDataInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDataInputStreamMethod "getAvailable" o = Gio.BufferedInputStream.BufferedInputStreamGetAvailableMethodInfo
ResolveDataInputStreamMethod "getBaseStream" o = Gio.FilterInputStream.FilterInputStreamGetBaseStreamMethodInfo
ResolveDataInputStreamMethod "getBufferSize" o = Gio.BufferedInputStream.BufferedInputStreamGetBufferSizeMethodInfo
ResolveDataInputStreamMethod "getByteOrder" o = DataInputStreamGetByteOrderMethodInfo
ResolveDataInputStreamMethod "getCloseBaseStream" o = Gio.FilterInputStream.FilterInputStreamGetCloseBaseStreamMethodInfo
ResolveDataInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDataInputStreamMethod "getNewlineType" o = DataInputStreamGetNewlineTypeMethodInfo
ResolveDataInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDataInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDataInputStreamMethod "setBufferSize" o = Gio.BufferedInputStream.BufferedInputStreamSetBufferSizeMethodInfo
ResolveDataInputStreamMethod "setByteOrder" o = DataInputStreamSetByteOrderMethodInfo
ResolveDataInputStreamMethod "setCloseBaseStream" o = Gio.FilterInputStream.FilterInputStreamSetCloseBaseStreamMethodInfo
ResolveDataInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDataInputStreamMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveDataInputStreamMethod "setNewlineType" o = DataInputStreamSetNewlineTypeMethodInfo
ResolveDataInputStreamMethod "setPending" o = Gio.InputStream.InputStreamSetPendingMethodInfo
ResolveDataInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDataInputStreamMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDataInputStreamMethod t DataInputStream, O.OverloadedMethod info DataInputStream p) => OL.IsLabel t (DataInputStream -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDataInputStreamMethod t DataInputStream, O.OverloadedMethod info DataInputStream p, R.HasField t DataInputStream p) => R.HasField t DataInputStream p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDataInputStreamMethod t DataInputStream, O.OverloadedMethodInfo info DataInputStream) => OL.IsLabel t (O.MethodProxy info DataInputStream) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
getDataInputStreamByteOrder :: (MonadIO m, IsDataInputStream o) => o -> m Gio.Enums.DataStreamByteOrder
getDataInputStreamByteOrder :: forall (m :: * -> *) o.
(MonadIO m, IsDataInputStream o) =>
o -> m DataStreamByteOrder
getDataInputStreamByteOrder o
obj = IO DataStreamByteOrder -> m DataStreamByteOrder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DataStreamByteOrder -> m DataStreamByteOrder)
-> IO DataStreamByteOrder -> m DataStreamByteOrder
forall a b. (a -> b) -> a -> b
$ o -> String -> IO DataStreamByteOrder
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"byte-order"
setDataInputStreamByteOrder :: (MonadIO m, IsDataInputStream o) => o -> Gio.Enums.DataStreamByteOrder -> m ()
setDataInputStreamByteOrder :: forall (m :: * -> *) o.
(MonadIO m, IsDataInputStream o) =>
o -> DataStreamByteOrder -> m ()
setDataInputStreamByteOrder o
obj DataStreamByteOrder
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> DataStreamByteOrder -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"byte-order" DataStreamByteOrder
val
constructDataInputStreamByteOrder :: (IsDataInputStream o, MIO.MonadIO m) => Gio.Enums.DataStreamByteOrder -> m (GValueConstruct o)
constructDataInputStreamByteOrder :: forall o (m :: * -> *).
(IsDataInputStream o, MonadIO m) =>
DataStreamByteOrder -> m (GValueConstruct o)
constructDataInputStreamByteOrder DataStreamByteOrder
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> DataStreamByteOrder -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"byte-order" DataStreamByteOrder
val
#if defined(ENABLE_OVERLOADING)
data DataInputStreamByteOrderPropertyInfo
instance AttrInfo DataInputStreamByteOrderPropertyInfo where
type AttrAllowedOps DataInputStreamByteOrderPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DataInputStreamByteOrderPropertyInfo = IsDataInputStream
type AttrSetTypeConstraint DataInputStreamByteOrderPropertyInfo = (~) Gio.Enums.DataStreamByteOrder
type AttrTransferTypeConstraint DataInputStreamByteOrderPropertyInfo = (~) Gio.Enums.DataStreamByteOrder
type AttrTransferType DataInputStreamByteOrderPropertyInfo = Gio.Enums.DataStreamByteOrder
type AttrGetType DataInputStreamByteOrderPropertyInfo = Gio.Enums.DataStreamByteOrder
type AttrLabel DataInputStreamByteOrderPropertyInfo = "byte-order"
type AttrOrigin DataInputStreamByteOrderPropertyInfo = DataInputStream
attrGet = getDataInputStreamByteOrder
attrSet = setDataInputStreamByteOrder
attrTransfer _ v = do
return v
attrConstruct = constructDataInputStreamByteOrder
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.byteOrder"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#g:attr:byteOrder"
})
#endif
getDataInputStreamNewlineType :: (MonadIO m, IsDataInputStream o) => o -> m Gio.Enums.DataStreamNewlineType
getDataInputStreamNewlineType :: forall (m :: * -> *) o.
(MonadIO m, IsDataInputStream o) =>
o -> m DataStreamNewlineType
getDataInputStreamNewlineType o
obj = IO DataStreamNewlineType -> m DataStreamNewlineType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO DataStreamNewlineType -> m DataStreamNewlineType)
-> IO DataStreamNewlineType -> m DataStreamNewlineType
forall a b. (a -> b) -> a -> b
$ o -> String -> IO DataStreamNewlineType
forall a b. (GObject a, Enum b, BoxedEnum b) => a -> String -> IO b
B.Properties.getObjectPropertyEnum o
obj String
"newline-type"
setDataInputStreamNewlineType :: (MonadIO m, IsDataInputStream o) => o -> Gio.Enums.DataStreamNewlineType -> m ()
setDataInputStreamNewlineType :: forall (m :: * -> *) o.
(MonadIO m, IsDataInputStream o) =>
o -> DataStreamNewlineType -> m ()
setDataInputStreamNewlineType o
obj DataStreamNewlineType
val = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
o -> String -> DataStreamNewlineType -> IO ()
forall a b.
(GObject a, Enum b, BoxedEnum b) =>
a -> String -> b -> IO ()
B.Properties.setObjectPropertyEnum o
obj String
"newline-type" DataStreamNewlineType
val
constructDataInputStreamNewlineType :: (IsDataInputStream o, MIO.MonadIO m) => Gio.Enums.DataStreamNewlineType -> m (GValueConstruct o)
constructDataInputStreamNewlineType :: forall o (m :: * -> *).
(IsDataInputStream o, MonadIO m) =>
DataStreamNewlineType -> m (GValueConstruct o)
constructDataInputStreamNewlineType DataStreamNewlineType
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> DataStreamNewlineType -> IO (GValueConstruct o)
forall a o.
(Enum a, BoxedEnum a) =>
String -> a -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyEnum String
"newline-type" DataStreamNewlineType
val
#if defined(ENABLE_OVERLOADING)
data DataInputStreamNewlineTypePropertyInfo
instance AttrInfo DataInputStreamNewlineTypePropertyInfo where
type AttrAllowedOps DataInputStreamNewlineTypePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrBaseTypeConstraint DataInputStreamNewlineTypePropertyInfo = IsDataInputStream
type AttrSetTypeConstraint DataInputStreamNewlineTypePropertyInfo = (~) Gio.Enums.DataStreamNewlineType
type AttrTransferTypeConstraint DataInputStreamNewlineTypePropertyInfo = (~) Gio.Enums.DataStreamNewlineType
type AttrTransferType DataInputStreamNewlineTypePropertyInfo = Gio.Enums.DataStreamNewlineType
type AttrGetType DataInputStreamNewlineTypePropertyInfo = Gio.Enums.DataStreamNewlineType
type AttrLabel DataInputStreamNewlineTypePropertyInfo = "newline-type"
type AttrOrigin DataInputStreamNewlineTypePropertyInfo = DataInputStream
attrGet = getDataInputStreamNewlineType
attrSet = setDataInputStreamNewlineType
attrTransfer _ v = do
return v
attrConstruct = constructDataInputStreamNewlineType
attrClear = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.newlineType"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#g:attr:newlineType"
})
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DataInputStream
type instance O.AttributeList DataInputStream = DataInputStreamAttributeList
type DataInputStreamAttributeList = ('[ '("baseStream", Gio.FilterInputStream.FilterInputStreamBaseStreamPropertyInfo), '("bufferSize", Gio.BufferedInputStream.BufferedInputStreamBufferSizePropertyInfo), '("byteOrder", DataInputStreamByteOrderPropertyInfo), '("closeBaseStream", Gio.FilterInputStream.FilterInputStreamCloseBaseStreamPropertyInfo), '("newlineType", DataInputStreamNewlineTypePropertyInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
dataInputStreamByteOrder :: AttrLabelProxy "byteOrder"
dataInputStreamByteOrder = AttrLabelProxy
dataInputStreamNewlineType :: AttrLabelProxy "newlineType"
dataInputStreamNewlineType = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList DataInputStream = DataInputStreamSignalList
type DataInputStreamSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_data_input_stream_new" g_data_input_stream_new ::
Ptr Gio.InputStream.InputStream ->
IO (Ptr DataInputStream)
dataInputStreamNew ::
(B.CallStack.HasCallStack, MonadIO m, Gio.InputStream.IsInputStream a) =>
a
-> m DataInputStream
dataInputStreamNew :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputStream a) =>
a -> m DataInputStream
dataInputStreamNew a
baseStream = IO DataInputStream -> m DataInputStream
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DataInputStream -> m DataInputStream)
-> IO DataInputStream -> m DataInputStream
forall a b. (a -> b) -> a -> b
$ do
baseStream' <- a -> IO (Ptr InputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
baseStream
result <- g_data_input_stream_new baseStream'
checkUnexpectedReturnNULL "dataInputStreamNew" result
result' <- (wrapObject DataInputStream) result
touchManagedPtr baseStream
return result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "g_data_input_stream_get_byte_order" g_data_input_stream_get_byte_order ::
Ptr DataInputStream ->
IO CUInt
dataInputStreamGetByteOrder ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a) =>
a
-> m Gio.Enums.DataStreamByteOrder
dataInputStreamGetByteOrder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDataInputStream a) =>
a -> m DataStreamByteOrder
dataInputStreamGetByteOrder a
stream = IO DataStreamByteOrder -> m DataStreamByteOrder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DataStreamByteOrder -> m DataStreamByteOrder)
-> IO DataStreamByteOrder -> m DataStreamByteOrder
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
result <- g_data_input_stream_get_byte_order stream'
let result' = (Int -> DataStreamByteOrder
forall a. Enum a => Int -> a
toEnum (Int -> DataStreamByteOrder)
-> (CUInt -> Int) -> CUInt -> DataStreamByteOrder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
touchManagedPtr stream
return result'
#if defined(ENABLE_OVERLOADING)
data DataInputStreamGetByteOrderMethodInfo
instance (signature ~ (m Gio.Enums.DataStreamByteOrder), MonadIO m, IsDataInputStream a) => O.OverloadedMethod DataInputStreamGetByteOrderMethodInfo a signature where
overloadedMethod = dataInputStreamGetByteOrder
instance O.OverloadedMethodInfo DataInputStreamGetByteOrderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamGetByteOrder",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamGetByteOrder"
})
#endif
foreign import ccall "g_data_input_stream_get_newline_type" g_data_input_stream_get_newline_type ::
Ptr DataInputStream ->
IO CUInt
dataInputStreamGetNewlineType ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a) =>
a
-> m Gio.Enums.DataStreamNewlineType
dataInputStreamGetNewlineType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDataInputStream a) =>
a -> m DataStreamNewlineType
dataInputStreamGetNewlineType a
stream = IO DataStreamNewlineType -> m DataStreamNewlineType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DataStreamNewlineType -> m DataStreamNewlineType)
-> IO DataStreamNewlineType -> m DataStreamNewlineType
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
result <- g_data_input_stream_get_newline_type stream'
let result' = (Int -> DataStreamNewlineType
forall a. Enum a => Int -> a
toEnum (Int -> DataStreamNewlineType)
-> (CUInt -> Int) -> CUInt -> DataStreamNewlineType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
touchManagedPtr stream
return result'
#if defined(ENABLE_OVERLOADING)
data DataInputStreamGetNewlineTypeMethodInfo
instance (signature ~ (m Gio.Enums.DataStreamNewlineType), MonadIO m, IsDataInputStream a) => O.OverloadedMethod DataInputStreamGetNewlineTypeMethodInfo a signature where
overloadedMethod = dataInputStreamGetNewlineType
instance O.OverloadedMethodInfo DataInputStreamGetNewlineTypeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamGetNewlineType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamGetNewlineType"
})
#endif
foreign import ccall "g_data_input_stream_read_byte" g_data_input_stream_read_byte ::
Ptr DataInputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Word8
dataInputStreamReadByte ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Word8
dataInputStreamReadByte :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m Word8
dataInputStreamReadByte a
stream Maybe b
cancellable = IO Word8 -> m Word8
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word8 -> m Word8) -> IO Word8 -> m Word8
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_byte stream' maybeCancellable
touchManagedPtr stream
whenJust cancellable touchManagedPtr
return result
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadByteMethodInfo
instance (signature ~ (Maybe (b) -> m Word8), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadByteMethodInfo a signature where
overloadedMethod = dataInputStreamReadByte
instance O.OverloadedMethodInfo DataInputStreamReadByteMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadByte",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadByte"
})
#endif
foreign import ccall "g_data_input_stream_read_int16" g_data_input_stream_read_int16 ::
Ptr DataInputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Int16
dataInputStreamReadInt16 ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Int16
dataInputStreamReadInt16 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m Int16
dataInputStreamReadInt16 a
stream Maybe b
cancellable = IO Int16 -> m Int16
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int16 -> m Int16) -> IO Int16 -> m Int16
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_int16 stream' maybeCancellable
touchManagedPtr stream
whenJust cancellable touchManagedPtr
return result
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadInt16MethodInfo
instance (signature ~ (Maybe (b) -> m Int16), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadInt16MethodInfo a signature where
overloadedMethod = dataInputStreamReadInt16
instance O.OverloadedMethodInfo DataInputStreamReadInt16MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadInt16",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadInt16"
})
#endif
foreign import ccall "g_data_input_stream_read_int32" g_data_input_stream_read_int32 ::
Ptr DataInputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Int32
dataInputStreamReadInt32 ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Int32
dataInputStreamReadInt32 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m Int32
dataInputStreamReadInt32 a
stream Maybe b
cancellable = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_int32 stream' maybeCancellable
touchManagedPtr stream
whenJust cancellable touchManagedPtr
return result
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadInt32MethodInfo
instance (signature ~ (Maybe (b) -> m Int32), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadInt32MethodInfo a signature where
overloadedMethod = dataInputStreamReadInt32
instance O.OverloadedMethodInfo DataInputStreamReadInt32MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadInt32",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadInt32"
})
#endif
foreign import ccall "g_data_input_stream_read_int64" g_data_input_stream_read_int64 ::
Ptr DataInputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Int64
dataInputStreamReadInt64 ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Int64
dataInputStreamReadInt64 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m Int64
dataInputStreamReadInt64 a
stream Maybe b
cancellable = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_int64 stream' maybeCancellable
touchManagedPtr stream
whenJust cancellable touchManagedPtr
return result
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadInt64MethodInfo
instance (signature ~ (Maybe (b) -> m Int64), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadInt64MethodInfo a signature where
overloadedMethod = dataInputStreamReadInt64
instance O.OverloadedMethodInfo DataInputStreamReadInt64MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadInt64",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadInt64"
})
#endif
foreign import ccall "g_data_input_stream_read_line" g_data_input_stream_read_line ::
Ptr DataInputStream ->
Ptr FCT.CSize ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO (Ptr Word8)
dataInputStreamReadLine ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m ((Maybe ByteString, FCT.CSize))
dataInputStreamReadLine :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m (Maybe ByteString, CSize)
dataInputStreamReadLine a
stream Maybe b
cancellable = IO (Maybe ByteString, CSize) -> m (Maybe ByteString, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ByteString, CSize) -> m (Maybe ByteString, CSize))
-> IO (Maybe ByteString, CSize) -> m (Maybe ByteString, CSize)
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
length_ <- allocMem :: IO (Ptr FCT.CSize)
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_line stream' length_ maybeCancellable
maybeResult <- convertIfNonNull result $ \Ptr Word8
result' -> do
result'' <- Ptr Word8 -> IO ByteString
unpackZeroTerminatedByteString Ptr Word8
result'
freeMem result'
return result''
length_' <- peek length_
touchManagedPtr stream
whenJust cancellable touchManagedPtr
freeMem length_
return (maybeResult, length_')
) (do
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadLineMethodInfo
instance (signature ~ (Maybe (b) -> m ((Maybe ByteString, FCT.CSize))), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadLineMethodInfo a signature where
overloadedMethod = dataInputStreamReadLine
instance O.OverloadedMethodInfo DataInputStreamReadLineMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadLine",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadLine"
})
#endif
foreign import ccall "g_data_input_stream_read_line_async" g_data_input_stream_read_line_async ::
Ptr DataInputStream ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
dataInputStreamReadLineAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
dataInputStreamReadLineAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
dataInputStreamReadLineAsync a
stream Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
maybeCallback <- case callback of
Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
forall a. FunPtr a
FP.nullFunPtr
Just AsyncReadyCallback
jCallback -> do
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
poke ptrcallback jCallback'
return jCallback'
let userData = Ptr a
forall a. Ptr a
nullPtr
g_data_input_stream_read_line_async stream' ioPriority maybeCancellable maybeCallback userData
touchManagedPtr stream
whenJust cancellable touchManagedPtr
return ()
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadLineAsyncMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadLineAsyncMethodInfo a signature where
overloadedMethod = dataInputStreamReadLineAsync
instance O.OverloadedMethodInfo DataInputStreamReadLineAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadLineAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadLineAsync"
})
#endif
foreign import ccall "g_data_input_stream_read_line_finish" g_data_input_stream_read_line_finish ::
Ptr DataInputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr FCT.CSize ->
Ptr (Ptr GError) ->
IO (Ptr Word8)
dataInputStreamReadLineFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ((Maybe ByteString, FCT.CSize))
dataInputStreamReadLineFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsAsyncResult b) =>
a -> b -> m (Maybe ByteString, CSize)
dataInputStreamReadLineFinish a
stream b
result_ = IO (Maybe ByteString, CSize) -> m (Maybe ByteString, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe ByteString, CSize) -> m (Maybe ByteString, CSize))
-> IO (Maybe ByteString, CSize) -> m (Maybe ByteString, CSize)
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
result_' <- unsafeManagedPtrCastPtr result_
length_ <- allocMem :: IO (Ptr FCT.CSize)
onException (do
result <- propagateGError $ g_data_input_stream_read_line_finish stream' result_' length_
maybeResult <- convertIfNonNull result $ \Ptr Word8
result' -> do
result'' <- Ptr Word8 -> IO ByteString
unpackZeroTerminatedByteString Ptr Word8
result'
freeMem result'
return result''
length_' <- peek length_
touchManagedPtr stream
touchManagedPtr result_
freeMem length_
return (maybeResult, length_')
) (do
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadLineFinishMethodInfo
instance (signature ~ (b -> m ((Maybe ByteString, FCT.CSize))), MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod DataInputStreamReadLineFinishMethodInfo a signature where
overloadedMethod = dataInputStreamReadLineFinish
instance O.OverloadedMethodInfo DataInputStreamReadLineFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadLineFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadLineFinish"
})
#endif
foreign import ccall "g_data_input_stream_read_line_finish_utf8" g_data_input_stream_read_line_finish_utf8 ::
Ptr DataInputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr FCT.CSize ->
Ptr (Ptr GError) ->
IO CString
dataInputStreamReadLineFinishUtf8 ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ((Maybe T.Text, FCT.CSize))
dataInputStreamReadLineFinishUtf8 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsAsyncResult b) =>
a -> b -> m (Maybe Text, CSize)
dataInputStreamReadLineFinishUtf8 a
stream b
result_ = IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, CSize) -> m (Maybe Text, CSize))
-> IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
result_' <- unsafeManagedPtrCastPtr result_
length_ <- allocMem :: IO (Ptr FCT.CSize)
onException (do
result <- propagateGError $ g_data_input_stream_read_line_finish_utf8 stream' result_' length_
maybeResult <- convertIfNonNull result $ \CString
result' -> do
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
freeMem result'
return result''
length_' <- peek length_
touchManagedPtr stream
touchManagedPtr result_
freeMem length_
return (maybeResult, length_')
) (do
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadLineFinishUtf8MethodInfo
instance (signature ~ (b -> m ((Maybe T.Text, FCT.CSize))), MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod DataInputStreamReadLineFinishUtf8MethodInfo a signature where
overloadedMethod = dataInputStreamReadLineFinishUtf8
instance O.OverloadedMethodInfo DataInputStreamReadLineFinishUtf8MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadLineFinishUtf8",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadLineFinishUtf8"
})
#endif
foreign import ccall "g_data_input_stream_read_line_utf8" g_data_input_stream_read_line_utf8 ::
Ptr DataInputStream ->
Ptr FCT.CSize ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CString
dataInputStreamReadLineUtf8 ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m ((Maybe T.Text, FCT.CSize))
dataInputStreamReadLineUtf8 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m (Maybe Text, CSize)
dataInputStreamReadLineUtf8 a
stream Maybe b
cancellable = IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text, CSize) -> m (Maybe Text, CSize))
-> IO (Maybe Text, CSize) -> m (Maybe Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
length_ <- allocMem :: IO (Ptr FCT.CSize)
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_line_utf8 stream' length_ maybeCancellable
maybeResult <- convertIfNonNull result $ \CString
result' -> do
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
freeMem result'
return result''
length_' <- peek length_
touchManagedPtr stream
whenJust cancellable touchManagedPtr
freeMem length_
return (maybeResult, length_')
) (do
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadLineUtf8MethodInfo
instance (signature ~ (Maybe (b) -> m ((Maybe T.Text, FCT.CSize))), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadLineUtf8MethodInfo a signature where
overloadedMethod = dataInputStreamReadLineUtf8
instance O.OverloadedMethodInfo DataInputStreamReadLineUtf8MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadLineUtf8",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadLineUtf8"
})
#endif
foreign import ccall "g_data_input_stream_read_uint16" g_data_input_stream_read_uint16 ::
Ptr DataInputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Word16
dataInputStreamReadUint16 ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Word16
dataInputStreamReadUint16 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m Word16
dataInputStreamReadUint16 a
stream Maybe b
cancellable = IO Word16 -> m Word16
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_uint16 stream' maybeCancellable
touchManagedPtr stream
whenJust cancellable touchManagedPtr
return result
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUint16MethodInfo
instance (signature ~ (Maybe (b) -> m Word16), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadUint16MethodInfo a signature where
overloadedMethod = dataInputStreamReadUint16
instance O.OverloadedMethodInfo DataInputStreamReadUint16MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUint16",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUint16"
})
#endif
foreign import ccall "g_data_input_stream_read_uint32" g_data_input_stream_read_uint32 ::
Ptr DataInputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Word32
dataInputStreamReadUint32 ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Word32
dataInputStreamReadUint32 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m Word32
dataInputStreamReadUint32 a
stream Maybe b
cancellable = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_uint32 stream' maybeCancellable
touchManagedPtr stream
whenJust cancellable touchManagedPtr
return result
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUint32MethodInfo
instance (signature ~ (Maybe (b) -> m Word32), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadUint32MethodInfo a signature where
overloadedMethod = dataInputStreamReadUint32
instance O.OverloadedMethodInfo DataInputStreamReadUint32MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUint32",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUint32"
})
#endif
foreign import ccall "g_data_input_stream_read_uint64" g_data_input_stream_read_uint64 ::
Ptr DataInputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Word64
dataInputStreamReadUint64 ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m Word64
dataInputStreamReadUint64 :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Maybe b -> m Word64
dataInputStreamReadUint64 a
stream Maybe b
cancellable = IO Word64 -> m Word64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word64 -> m Word64) -> IO Word64 -> m Word64
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_uint64 stream' maybeCancellable
touchManagedPtr stream
whenJust cancellable touchManagedPtr
return result
) (do
return ()
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUint64MethodInfo
instance (signature ~ (Maybe (b) -> m Word64), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadUint64MethodInfo a signature where
overloadedMethod = dataInputStreamReadUint64
instance O.OverloadedMethodInfo DataInputStreamReadUint64MethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUint64",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUint64"
})
#endif
foreign import ccall "g_data_input_stream_read_until" g_data_input_stream_read_until ::
Ptr DataInputStream ->
CString ->
Ptr FCT.CSize ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CString
{-# DEPRECATED dataInputStreamReadUntil ["(Since version 2.56)","Use 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUpto' instead, which has more"," consistent behaviour regarding the stop character."] #-}
dataInputStreamReadUntil ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> T.Text
-> Maybe (b)
-> m ((T.Text, FCT.CSize))
dataInputStreamReadUntil :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Text -> Maybe b -> m (Text, CSize)
dataInputStreamReadUntil a
stream Text
stopChars Maybe b
cancellable = IO (Text, CSize) -> m (Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, CSize) -> m (Text, CSize))
-> IO (Text, CSize) -> m (Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
stopChars' <- textToCString stopChars
length_ <- allocMem :: IO (Ptr FCT.CSize)
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_until stream' stopChars' length_ maybeCancellable
checkUnexpectedReturnNULL "dataInputStreamReadUntil" result
result' <- cstringToText result
freeMem result
length_' <- peek length_
touchManagedPtr stream
whenJust cancellable touchManagedPtr
freeMem stopChars'
freeMem length_
return (result', length_')
) (do
freeMem stopChars'
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUntilMethodInfo
instance (signature ~ (T.Text -> Maybe (b) -> m ((T.Text, FCT.CSize))), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadUntilMethodInfo a signature where
overloadedMethod = dataInputStreamReadUntil
instance O.OverloadedMethodInfo DataInputStreamReadUntilMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUntil",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUntil"
})
#endif
foreign import ccall "g_data_input_stream_read_until_async" g_data_input_stream_read_until_async ::
Ptr DataInputStream ->
CString ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
{-# DEPRECATED dataInputStreamReadUntilAsync ["(Since version 2.56)","Use 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoAsync' instead, which"," has more consistent behaviour regarding the stop character."] #-}
dataInputStreamReadUntilAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> T.Text
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
dataInputStreamReadUntilAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Text -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
dataInputStreamReadUntilAsync a
stream Text
stopChars Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
stopChars' <- textToCString stopChars
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
maybeCallback <- case callback of
Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
forall a. FunPtr a
FP.nullFunPtr
Just AsyncReadyCallback
jCallback -> do
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
poke ptrcallback jCallback'
return jCallback'
let userData = Ptr a
forall a. Ptr a
nullPtr
g_data_input_stream_read_until_async stream' stopChars' ioPriority maybeCancellable maybeCallback userData
touchManagedPtr stream
whenJust cancellable touchManagedPtr
freeMem stopChars'
return ()
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUntilAsyncMethodInfo
instance (signature ~ (T.Text -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadUntilAsyncMethodInfo a signature where
overloadedMethod = dataInputStreamReadUntilAsync
instance O.OverloadedMethodInfo DataInputStreamReadUntilAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUntilAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUntilAsync"
})
#endif
foreign import ccall "g_data_input_stream_read_until_finish" g_data_input_stream_read_until_finish ::
Ptr DataInputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr FCT.CSize ->
Ptr (Ptr GError) ->
IO CString
{-# DEPRECATED dataInputStreamReadUntilFinish ["(Since version 2.56)","Use 'GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoFinish' instead, which"," has more consistent behaviour regarding the stop character."] #-}
dataInputStreamReadUntilFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ((T.Text, FCT.CSize))
dataInputStreamReadUntilFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsAsyncResult b) =>
a -> b -> m (Text, CSize)
dataInputStreamReadUntilFinish a
stream b
result_ = IO (Text, CSize) -> m (Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, CSize) -> m (Text, CSize))
-> IO (Text, CSize) -> m (Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
result_' <- unsafeManagedPtrCastPtr result_
length_ <- allocMem :: IO (Ptr FCT.CSize)
onException (do
result <- propagateGError $ g_data_input_stream_read_until_finish stream' result_' length_
checkUnexpectedReturnNULL "dataInputStreamReadUntilFinish" result
result' <- cstringToText result
freeMem result
length_' <- peek length_
touchManagedPtr stream
touchManagedPtr result_
freeMem length_
return (result', length_')
) (do
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUntilFinishMethodInfo
instance (signature ~ (b -> m ((T.Text, FCT.CSize))), MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod DataInputStreamReadUntilFinishMethodInfo a signature where
overloadedMethod = dataInputStreamReadUntilFinish
instance O.OverloadedMethodInfo DataInputStreamReadUntilFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUntilFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUntilFinish"
})
#endif
foreign import ccall "g_data_input_stream_read_upto" g_data_input_stream_read_upto ::
Ptr DataInputStream ->
CString ->
DI.Int64 ->
Ptr FCT.CSize ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CString
dataInputStreamReadUpto ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> T.Text
-> DI.Int64
-> Maybe (b)
-> m ((T.Text, FCT.CSize))
dataInputStreamReadUpto :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a -> Text -> Int64 -> Maybe b -> m (Text, CSize)
dataInputStreamReadUpto a
stream Text
stopChars Int64
stopCharsLen Maybe b
cancellable = IO (Text, CSize) -> m (Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, CSize) -> m (Text, CSize))
-> IO (Text, CSize) -> m (Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
stopChars' <- textToCString stopChars
length_ <- allocMem :: IO (Ptr FCT.CSize)
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
onException (do
result <- propagateGError $ g_data_input_stream_read_upto stream' stopChars' stopCharsLen length_ maybeCancellable
checkUnexpectedReturnNULL "dataInputStreamReadUpto" result
result' <- cstringToText result
freeMem result
length_' <- peek length_
touchManagedPtr stream
whenJust cancellable touchManagedPtr
freeMem stopChars'
freeMem length_
return (result', length_')
) (do
freeMem stopChars'
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUptoMethodInfo
instance (signature ~ (T.Text -> DI.Int64 -> Maybe (b) -> m ((T.Text, FCT.CSize))), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadUptoMethodInfo a signature where
overloadedMethod = dataInputStreamReadUpto
instance O.OverloadedMethodInfo DataInputStreamReadUptoMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUpto",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUpto"
})
#endif
foreign import ccall "g_data_input_stream_read_upto_async" g_data_input_stream_read_upto_async ::
Ptr DataInputStream ->
CString ->
DI.Int64 ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
dataInputStreamReadUptoAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> T.Text
-> DI.Int64
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
dataInputStreamReadUptoAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsCancellable b) =>
a
-> Text
-> Int64
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ()
dataInputStreamReadUptoAsync a
stream Text
stopChars Int64
stopCharsLen Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
stopChars' <- textToCString stopChars
maybeCancellable <- case cancellable of
Maybe b
Nothing -> Ptr Cancellable -> IO (Ptr Cancellable)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
forall a. Ptr a
FP.nullPtr
Just b
jCancellable -> do
jCancellable' <- b -> IO (Ptr Cancellable)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
return jCancellable'
maybeCallback <- case callback of
Maybe AsyncReadyCallback
Nothing -> FunPtr C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
forall a. FunPtr a
FP.nullFunPtr
Just AsyncReadyCallback
jCallback -> do
ptrcallback <- IO (Ptr (FunPtr C_AsyncReadyCallback))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
poke ptrcallback jCallback'
return jCallback'
let userData = Ptr a
forall a. Ptr a
nullPtr
g_data_input_stream_read_upto_async stream' stopChars' stopCharsLen ioPriority maybeCancellable maybeCallback userData
touchManagedPtr stream
whenJust cancellable touchManagedPtr
freeMem stopChars'
return ()
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUptoAsyncMethodInfo
instance (signature ~ (T.Text -> DI.Int64 -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDataInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod DataInputStreamReadUptoAsyncMethodInfo a signature where
overloadedMethod = dataInputStreamReadUptoAsync
instance O.OverloadedMethodInfo DataInputStreamReadUptoAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUptoAsync"
})
#endif
foreign import ccall "g_data_input_stream_read_upto_finish" g_data_input_stream_read_upto_finish ::
Ptr DataInputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr FCT.CSize ->
Ptr (Ptr GError) ->
IO CString
dataInputStreamReadUptoFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ((T.Text, FCT.CSize))
dataInputStreamReadUptoFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsDataInputStream a, IsAsyncResult b) =>
a -> b -> m (Text, CSize)
dataInputStreamReadUptoFinish a
stream b
result_ = IO (Text, CSize) -> m (Text, CSize)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Text, CSize) -> m (Text, CSize))
-> IO (Text, CSize) -> m (Text, CSize)
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
result_' <- unsafeManagedPtrCastPtr result_
length_ <- allocMem :: IO (Ptr FCT.CSize)
onException (do
result <- propagateGError $ g_data_input_stream_read_upto_finish stream' result_' length_
checkUnexpectedReturnNULL "dataInputStreamReadUptoFinish" result
result' <- cstringToText result
freeMem result
length_' <- peek length_
touchManagedPtr stream
touchManagedPtr result_
freeMem length_
return (result', length_')
) (do
freeMem length_
)
#if defined(ENABLE_OVERLOADING)
data DataInputStreamReadUptoFinishMethodInfo
instance (signature ~ (b -> m ((T.Text, FCT.CSize))), MonadIO m, IsDataInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod DataInputStreamReadUptoFinishMethodInfo a signature where
overloadedMethod = dataInputStreamReadUptoFinish
instance O.OverloadedMethodInfo DataInputStreamReadUptoFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamReadUptoFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamReadUptoFinish"
})
#endif
foreign import ccall "g_data_input_stream_set_byte_order" g_data_input_stream_set_byte_order ::
Ptr DataInputStream ->
CUInt ->
IO ()
dataInputStreamSetByteOrder ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a) =>
a
-> Gio.Enums.DataStreamByteOrder
-> m ()
dataInputStreamSetByteOrder :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDataInputStream a) =>
a -> DataStreamByteOrder -> m ()
dataInputStreamSetByteOrder a
stream DataStreamByteOrder
order = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
let order' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (DataStreamByteOrder -> Int) -> DataStreamByteOrder -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataStreamByteOrder -> Int
forall a. Enum a => a -> Int
fromEnum) DataStreamByteOrder
order
g_data_input_stream_set_byte_order stream' order'
touchManagedPtr stream
return ()
#if defined(ENABLE_OVERLOADING)
data DataInputStreamSetByteOrderMethodInfo
instance (signature ~ (Gio.Enums.DataStreamByteOrder -> m ()), MonadIO m, IsDataInputStream a) => O.OverloadedMethod DataInputStreamSetByteOrderMethodInfo a signature where
overloadedMethod = dataInputStreamSetByteOrder
instance O.OverloadedMethodInfo DataInputStreamSetByteOrderMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamSetByteOrder",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamSetByteOrder"
})
#endif
foreign import ccall "g_data_input_stream_set_newline_type" g_data_input_stream_set_newline_type ::
Ptr DataInputStream ->
CUInt ->
IO ()
dataInputStreamSetNewlineType ::
(B.CallStack.HasCallStack, MonadIO m, IsDataInputStream a) =>
a
-> Gio.Enums.DataStreamNewlineType
-> m ()
dataInputStreamSetNewlineType :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsDataInputStream a) =>
a -> DataStreamNewlineType -> m ()
dataInputStreamSetNewlineType a
stream DataStreamNewlineType
type_ = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
stream' <- a -> IO (Ptr DataInputStream)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
let type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt)
-> (DataStreamNewlineType -> Int) -> DataStreamNewlineType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DataStreamNewlineType -> Int
forall a. Enum a => a -> Int
fromEnum) DataStreamNewlineType
type_
g_data_input_stream_set_newline_type stream' type_'
touchManagedPtr stream
return ()
#if defined(ENABLE_OVERLOADING)
data DataInputStreamSetNewlineTypeMethodInfo
instance (signature ~ (Gio.Enums.DataStreamNewlineType -> m ()), MonadIO m, IsDataInputStream a) => O.OverloadedMethod DataInputStreamSetNewlineTypeMethodInfo a signature where
overloadedMethod = dataInputStreamSetNewlineType
instance O.OverloadedMethodInfo DataInputStreamSetNewlineTypeMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.DataInputStream.dataInputStreamSetNewlineType",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Objects-DataInputStream.html#v:dataInputStreamSetNewlineType"
})
#endif