{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Objects.InputStream
(
InputStream(..) ,
IsInputStream ,
toInputStream ,
#if defined(ENABLE_OVERLOADING)
ResolveInputStreamMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
InputStreamClearPendingMethodInfo ,
#endif
inputStreamClearPending ,
#if defined(ENABLE_OVERLOADING)
InputStreamCloseMethodInfo ,
#endif
inputStreamClose ,
#if defined(ENABLE_OVERLOADING)
InputStreamCloseAsyncMethodInfo ,
#endif
inputStreamCloseAsync ,
#if defined(ENABLE_OVERLOADING)
InputStreamCloseFinishMethodInfo ,
#endif
inputStreamCloseFinish ,
#if defined(ENABLE_OVERLOADING)
InputStreamHasPendingMethodInfo ,
#endif
inputStreamHasPending ,
#if defined(ENABLE_OVERLOADING)
InputStreamIsClosedMethodInfo ,
#endif
inputStreamIsClosed ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadMethodInfo ,
#endif
inputStreamRead ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadAllMethodInfo ,
#endif
inputStreamReadAll ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadAllAsyncMethodInfo ,
#endif
inputStreamReadAllAsync ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadAllFinishMethodInfo ,
#endif
inputStreamReadAllFinish ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadAsyncMethodInfo ,
#endif
inputStreamReadAsync ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadBytesMethodInfo ,
#endif
inputStreamReadBytes ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadBytesAsyncMethodInfo ,
#endif
inputStreamReadBytesAsync ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadBytesFinishMethodInfo ,
#endif
inputStreamReadBytesFinish ,
#if defined(ENABLE_OVERLOADING)
InputStreamReadFinishMethodInfo ,
#endif
inputStreamReadFinish ,
#if defined(ENABLE_OVERLOADING)
InputStreamSetPendingMethodInfo ,
#endif
inputStreamSetPending ,
#if defined(ENABLE_OVERLOADING)
InputStreamSkipMethodInfo ,
#endif
inputStreamSkip ,
#if defined(ENABLE_OVERLOADING)
InputStreamSkipAsyncMethodInfo ,
#endif
inputStreamSkipAsync ,
#if defined(ENABLE_OVERLOADING)
InputStreamSkipFinishMethodInfo ,
#endif
inputStreamSkipFinish ,
) 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 GI.GLib.Structs.Bytes as GLib.Bytes
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
newtype InputStream = InputStream (SP.ManagedPtr InputStream)
deriving (InputStream -> InputStream -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: InputStream -> InputStream -> Bool
$c/= :: InputStream -> InputStream -> Bool
== :: InputStream -> InputStream -> Bool
$c== :: InputStream -> InputStream -> Bool
Eq)
instance SP.ManagedPtrNewtype InputStream where
toManagedPtr :: InputStream -> ManagedPtr InputStream
toManagedPtr (InputStream ManagedPtr InputStream
p) = ManagedPtr InputStream
p
foreign import ccall "g_input_stream_get_type"
c_g_input_stream_get_type :: IO B.Types.GType
instance B.Types.TypedObject InputStream where
glibType :: IO GType
glibType = IO GType
c_g_input_stream_get_type
instance B.Types.GObject InputStream
class (SP.GObject o, O.IsDescendantOf InputStream o) => IsInputStream o
instance (SP.GObject o, O.IsDescendantOf InputStream o) => IsInputStream o
instance O.HasParentTypes InputStream
type instance O.ParentTypes InputStream = '[GObject.Object.Object]
toInputStream :: (MIO.MonadIO m, IsInputStream o) => o -> m InputStream
toInputStream :: forall (m :: * -> *) o.
(MonadIO m, IsInputStream o) =>
o -> m InputStream
toInputStream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr InputStream -> InputStream
InputStream
instance B.GValue.IsGValue (Maybe InputStream) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_input_stream_get_type
gvalueSet_ :: Ptr GValue -> Maybe InputStream -> IO ()
gvalueSet_ Ptr GValue
gv Maybe InputStream
P.Nothing = forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr InputStream)
gvalueSet_ Ptr GValue
gv (P.Just InputStream
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr InputStream
obj (forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe InputStream)
gvalueGet_ Ptr GValue
gv = do
Ptr InputStream
ptr <- forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr InputStream)
if Ptr InputStream
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr InputStream -> InputStream
InputStream Ptr InputStream
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
#if defined(ENABLE_OVERLOADING)
type family ResolveInputStreamMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveInputStreamMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveInputStreamMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveInputStreamMethod "clearPending" o = InputStreamClearPendingMethodInfo
ResolveInputStreamMethod "close" o = InputStreamCloseMethodInfo
ResolveInputStreamMethod "closeAsync" o = InputStreamCloseAsyncMethodInfo
ResolveInputStreamMethod "closeFinish" o = InputStreamCloseFinishMethodInfo
ResolveInputStreamMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveInputStreamMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveInputStreamMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveInputStreamMethod "hasPending" o = InputStreamHasPendingMethodInfo
ResolveInputStreamMethod "isClosed" o = InputStreamIsClosedMethodInfo
ResolveInputStreamMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveInputStreamMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveInputStreamMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveInputStreamMethod "read" o = InputStreamReadMethodInfo
ResolveInputStreamMethod "readAll" o = InputStreamReadAllMethodInfo
ResolveInputStreamMethod "readAllAsync" o = InputStreamReadAllAsyncMethodInfo
ResolveInputStreamMethod "readAllFinish" o = InputStreamReadAllFinishMethodInfo
ResolveInputStreamMethod "readAsync" o = InputStreamReadAsyncMethodInfo
ResolveInputStreamMethod "readBytes" o = InputStreamReadBytesMethodInfo
ResolveInputStreamMethod "readBytesAsync" o = InputStreamReadBytesAsyncMethodInfo
ResolveInputStreamMethod "readBytesFinish" o = InputStreamReadBytesFinishMethodInfo
ResolveInputStreamMethod "readFinish" o = InputStreamReadFinishMethodInfo
ResolveInputStreamMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveInputStreamMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveInputStreamMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveInputStreamMethod "skip" o = InputStreamSkipMethodInfo
ResolveInputStreamMethod "skipAsync" o = InputStreamSkipAsyncMethodInfo
ResolveInputStreamMethod "skipFinish" o = InputStreamSkipFinishMethodInfo
ResolveInputStreamMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveInputStreamMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveInputStreamMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveInputStreamMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveInputStreamMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveInputStreamMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveInputStreamMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveInputStreamMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveInputStreamMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveInputStreamMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
ResolveInputStreamMethod "setPending" o = InputStreamSetPendingMethodInfo
ResolveInputStreamMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveInputStreamMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveInputStreamMethod t InputStream, O.OverloadedMethod info InputStream p) => OL.IsLabel t (InputStream -> 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 ~ ResolveInputStreamMethod t InputStream, O.OverloadedMethod info InputStream p, R.HasField t InputStream p) => R.HasField t InputStream p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveInputStreamMethod t InputStream, O.OverloadedMethodInfo info InputStream) => OL.IsLabel t (O.MethodProxy info InputStream) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList InputStream
type instance O.AttributeList InputStream = InputStreamAttributeList
type InputStreamAttributeList = ('[ ] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
#endif
#if defined(ENABLE_OVERLOADING)
type instance O.SignalList InputStream = InputStreamSignalList
type InputStreamSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_input_stream_clear_pending" g_input_stream_clear_pending ::
Ptr InputStream ->
IO ()
inputStreamClearPending ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a) =>
a
-> m ()
inputStreamClearPending :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputStream a) =>
a -> m ()
inputStreamClearPending a
stream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr InputStream -> IO ()
g_input_stream_clear_pending Ptr InputStream
stream'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data InputStreamClearPendingMethodInfo
instance (signature ~ (m ()), MonadIO m, IsInputStream a) => O.OverloadedMethod InputStreamClearPendingMethodInfo a signature where
overloadedMethod = inputStreamClearPending
instance O.OverloadedMethodInfo InputStreamClearPendingMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamClearPending",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamClearPending"
})
#endif
foreign import ccall "g_input_stream_close" g_input_stream_close ::
Ptr InputStream ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
inputStreamClose ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (b)
-> m ()
inputStreamClose :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> Maybe b -> m ()
inputStreamClose a
stream Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream -> Ptr Cancellable -> Ptr (Ptr GError) -> IO CInt
g_input_stream_close Ptr InputStream
stream' Ptr Cancellable
maybeCancellable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data InputStreamCloseMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamCloseMethodInfo a signature where
overloadedMethod = inputStreamClose
instance O.OverloadedMethodInfo InputStreamCloseMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamClose",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamClose"
})
#endif
foreign import ccall "g_input_stream_close_async" g_input_stream_close_async ::
Ptr InputStream ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
inputStreamCloseAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
inputStreamCloseAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
inputStreamCloseAsync a
stream Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr InputStream
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_input_stream_close_async Ptr InputStream
stream' Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data InputStreamCloseAsyncMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamCloseAsyncMethodInfo a signature where
overloadedMethod = inputStreamCloseAsync
instance O.OverloadedMethodInfo InputStreamCloseAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamCloseAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamCloseAsync"
})
#endif
foreign import ccall "g_input_stream_close_finish" g_input_stream_close_finish ::
Ptr InputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO CInt
inputStreamCloseFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m ()
inputStreamCloseFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
a -> b -> m ()
inputStreamCloseFinish a
stream b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO CInt
g_input_stream_close_finish Ptr InputStream
stream' Ptr AsyncResult
result_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data InputStreamCloseFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod InputStreamCloseFinishMethodInfo a signature where
overloadedMethod = inputStreamCloseFinish
instance O.OverloadedMethodInfo InputStreamCloseFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamCloseFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamCloseFinish"
})
#endif
foreign import ccall "g_input_stream_has_pending" g_input_stream_has_pending ::
Ptr InputStream ->
IO CInt
inputStreamHasPending ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a) =>
a
-> m Bool
inputStreamHasPending :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputStream a) =>
a -> m Bool
inputStreamHasPending a
stream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
CInt
result <- Ptr InputStream -> IO CInt
g_input_stream_has_pending Ptr InputStream
stream'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data InputStreamHasPendingMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsInputStream a) => O.OverloadedMethod InputStreamHasPendingMethodInfo a signature where
overloadedMethod = inputStreamHasPending
instance O.OverloadedMethodInfo InputStreamHasPendingMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamHasPending",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamHasPending"
})
#endif
foreign import ccall "g_input_stream_is_closed" g_input_stream_is_closed ::
Ptr InputStream ->
IO CInt
inputStreamIsClosed ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a) =>
a
-> m Bool
inputStreamIsClosed :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputStream a) =>
a -> m Bool
inputStreamIsClosed a
stream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
CInt
result <- Ptr InputStream -> IO CInt
g_input_stream_is_closed Ptr InputStream
stream'
let result' :: Bool
result' = (forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data InputStreamIsClosedMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsInputStream a) => O.OverloadedMethod InputStreamIsClosedMethodInfo a signature where
overloadedMethod = inputStreamIsClosed
instance O.OverloadedMethodInfo InputStreamIsClosedMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamIsClosed",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamIsClosed"
})
#endif
foreign import ccall "g_input_stream_read" g_input_stream_read ::
Ptr InputStream ->
Ptr Word8 ->
Word32 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Int32
inputStreamRead ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> ByteString
-> Maybe (b)
-> m ((Int32, ByteString))
inputStreamRead :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> ByteString -> Maybe b -> m (Int32, ByteString)
inputStreamRead a
stream ByteString
buffer Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let count :: Word32
count = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
buffer
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Word8
buffer' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
buffer
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
Int32
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Ptr Word8
-> Word32
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO Int32
g_input_stream_read Ptr InputStream
stream' Ptr Word8
buffer' Word32
count Ptr Cancellable
maybeCancellable
ByteString
buffer'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Word32
count) Ptr Word8
buffer'
forall a. Ptr a -> IO ()
freeMem Ptr Word8
buffer'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return (Int32
result, ByteString
buffer'')
) (do
forall a. Ptr a -> IO ()
freeMem Ptr Word8
buffer'
)
#if defined(ENABLE_OVERLOADING)
data InputStreamReadMethodInfo
instance (signature ~ (ByteString -> Maybe (b) -> m ((Int32, ByteString))), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamReadMethodInfo a signature where
overloadedMethod = inputStreamRead
instance O.OverloadedMethodInfo InputStreamReadMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamRead",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamRead"
})
#endif
foreign import ccall "g_input_stream_read_all" g_input_stream_read_all ::
Ptr InputStream ->
Ptr Word8 ->
Word32 ->
Ptr Word32 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO CInt
inputStreamReadAll ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> ByteString
-> Maybe (b)
-> m ((ByteString, Word32))
inputStreamReadAll :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> ByteString -> Maybe b -> m (ByteString, Word32)
inputStreamReadAll a
stream ByteString
buffer Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let count :: Word32
count = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
buffer
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Word8
buffer' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
buffer
Ptr Word32
bytesRead <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Ptr Word8
-> Word32
-> Ptr Word32
-> Ptr Cancellable
-> Ptr (Ptr GError)
-> IO CInt
g_input_stream_read_all Ptr InputStream
stream' Ptr Word8
buffer' Word32
count Ptr Word32
bytesRead Ptr Cancellable
maybeCancellable
ByteString
buffer'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Word32
count) Ptr Word8
buffer'
forall a. Ptr a -> IO ()
freeMem Ptr Word8
buffer'
Word32
bytesRead' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
bytesRead
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall a. Ptr a -> IO ()
freeMem Ptr Word32
bytesRead
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString
buffer'', Word32
bytesRead')
) (do
forall a. Ptr a -> IO ()
freeMem Ptr Word8
buffer'
forall a. Ptr a -> IO ()
freeMem Ptr Word32
bytesRead
)
#if defined(ENABLE_OVERLOADING)
data InputStreamReadAllMethodInfo
instance (signature ~ (ByteString -> Maybe (b) -> m ((ByteString, Word32))), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamReadAllMethodInfo a signature where
overloadedMethod = inputStreamReadAll
instance O.OverloadedMethodInfo InputStreamReadAllMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamReadAll",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamReadAll"
})
#endif
foreign import ccall "g_input_stream_read_all_async" g_input_stream_read_all_async ::
Ptr InputStream ->
Ptr Word8 ->
Word32 ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
inputStreamReadAllAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> ByteString
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m (ByteString)
inputStreamReadAllAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a
-> ByteString
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback
-> m ByteString
inputStreamReadAllAsync a
stream ByteString
buffer Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let count :: Word32
count = forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
buffer
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Word8
buffer' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
buffer
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr InputStream
-> Ptr Word8
-> Word32
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_input_stream_read_all_async Ptr InputStream
stream' Ptr Word8
buffer' Word32
count Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
ByteString
buffer'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Word32
count) Ptr Word8
buffer'
forall a. Ptr a -> IO ()
freeMem Ptr Word8
buffer'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
buffer''
#if defined(ENABLE_OVERLOADING)
data InputStreamReadAllAsyncMethodInfo
instance (signature ~ (ByteString -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m (ByteString)), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamReadAllAsyncMethodInfo a signature where
overloadedMethod = inputStreamReadAllAsync
instance O.OverloadedMethodInfo InputStreamReadAllAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamReadAllAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamReadAllAsync"
})
#endif
foreign import ccall "g_input_stream_read_all_finish" g_input_stream_read_all_finish ::
Ptr InputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr Word32 ->
Ptr (Ptr GError) ->
IO CInt
inputStreamReadAllFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m (Word32)
inputStreamReadAllFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
a -> b -> m Word32
inputStreamReadAllFinish a
stream b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
Ptr Word32
bytesRead <- forall a. Storable a => IO (Ptr a)
allocMem :: IO (Ptr Word32)
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Ptr AsyncResult -> Ptr Word32 -> Ptr (Ptr GError) -> IO CInt
g_input_stream_read_all_finish Ptr InputStream
stream' Ptr AsyncResult
result_' Ptr Word32
bytesRead
Word32
bytesRead' <- forall a. Storable a => Ptr a -> IO a
peek Ptr Word32
bytesRead
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall a. Ptr a -> IO ()
freeMem Ptr Word32
bytesRead
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
bytesRead'
) (do
forall a. Ptr a -> IO ()
freeMem Ptr Word32
bytesRead
)
#if defined(ENABLE_OVERLOADING)
data InputStreamReadAllFinishMethodInfo
instance (signature ~ (b -> m (Word32)), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod InputStreamReadAllFinishMethodInfo a signature where
overloadedMethod = inputStreamReadAllFinish
instance O.OverloadedMethodInfo InputStreamReadAllFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamReadAllFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamReadAllFinish"
})
#endif
foreign import ccall "g_input_stream_read_async" g_input_stream_read_async ::
Ptr InputStream ->
Ptr Word8 ->
Word32 ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
inputStreamReadAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Maybe (ByteString)
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ((Maybe ByteString))
inputStreamReadAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a
-> Maybe ByteString
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback
-> m (Maybe ByteString)
inputStreamReadAsync a
stream Maybe ByteString
buffer Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
let count :: Word32
count = case Maybe ByteString
buffer of
Maybe ByteString
Nothing -> Word32
0
Just ByteString
jBuffer -> forall a b. (Integral a, Num b) => a -> b
fromIntegral forall a b. (a -> b) -> a -> b
$ ByteString -> Int
B.length ByteString
jBuffer
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Word8
maybeBuffer <- case Maybe ByteString
buffer of
Maybe ByteString
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just ByteString
jBuffer -> do
Ptr Word8
jBuffer' <- ByteString -> IO (Ptr Word8)
packByteString ByteString
jBuffer
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Word8
jBuffer'
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr InputStream
-> Ptr Word8
-> Word32
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_input_stream_read_async Ptr InputStream
stream' Ptr Word8
maybeBuffer Word32
count Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
Maybe ByteString
maybeMaybeBuffer <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Word8
maybeBuffer forall a b. (a -> b) -> a -> b
$ \Ptr Word8
maybeBuffer' -> do
ByteString
maybeBuffer'' <- (forall a. Integral a => a -> Ptr Word8 -> IO ByteString
unpackByteStringWithLength Word32
count) Ptr Word8
maybeBuffer'
forall a. Ptr a -> IO ()
freeMem Ptr Word8
maybeBuffer'
forall (m :: * -> *) a. Monad m => a -> m a
return ByteString
maybeBuffer''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ByteString
maybeMaybeBuffer
#if defined(ENABLE_OVERLOADING)
data InputStreamReadAsyncMethodInfo
instance (signature ~ (Maybe (ByteString) -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ((Maybe ByteString))), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamReadAsyncMethodInfo a signature where
overloadedMethod = inputStreamReadAsync
instance O.OverloadedMethodInfo InputStreamReadAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamReadAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamReadAsync"
})
#endif
foreign import ccall "g_input_stream_read_bytes" g_input_stream_read_bytes ::
Ptr InputStream ->
Word32 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO (Ptr GLib.Bytes.Bytes)
inputStreamReadBytes ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Word32
-> Maybe (b)
-> m GLib.Bytes.Bytes
inputStreamReadBytes :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> Word32 -> Maybe b -> m Bytes
inputStreamReadBytes a
stream Word32
count Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Bytes
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Word32 -> Ptr Cancellable -> Ptr (Ptr GError) -> IO (Ptr Bytes)
g_input_stream_read_bytes Ptr InputStream
stream' Word32
count Ptr Cancellable
maybeCancellable
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inputStreamReadBytes" Ptr Bytes
result
Bytes
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result'
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data InputStreamReadBytesMethodInfo
instance (signature ~ (Word32 -> Maybe (b) -> m GLib.Bytes.Bytes), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamReadBytesMethodInfo a signature where
overloadedMethod = inputStreamReadBytes
instance O.OverloadedMethodInfo InputStreamReadBytesMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamReadBytes",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamReadBytes"
})
#endif
foreign import ccall "g_input_stream_read_bytes_async" g_input_stream_read_bytes_async ::
Ptr InputStream ->
Word32 ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
inputStreamReadBytesAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Word32
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
inputStreamReadBytesAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> Word32 -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
inputStreamReadBytesAsync a
stream Word32
count Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr InputStream
-> Word32
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_input_stream_read_bytes_async Ptr InputStream
stream' Word32
count Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data InputStreamReadBytesAsyncMethodInfo
instance (signature ~ (Word32 -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamReadBytesAsyncMethodInfo a signature where
overloadedMethod = inputStreamReadBytesAsync
instance O.OverloadedMethodInfo InputStreamReadBytesAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamReadBytesAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamReadBytesAsync"
})
#endif
foreign import ccall "g_input_stream_read_bytes_finish" g_input_stream_read_bytes_finish ::
Ptr InputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO (Ptr GLib.Bytes.Bytes)
inputStreamReadBytesFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m GLib.Bytes.Bytes
inputStreamReadBytesFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
a -> b -> m Bytes
inputStreamReadBytesFinish a
stream b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
forall a b. IO a -> IO b -> IO a
onException (do
Ptr Bytes
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Ptr AsyncResult -> Ptr (Ptr GError) -> IO (Ptr Bytes)
g_input_stream_read_bytes_finish Ptr InputStream
stream' Ptr AsyncResult
result_'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"inputStreamReadBytesFinish" Ptr Bytes
result
Bytes
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Bytes -> Bytes
GLib.Bytes.Bytes) Ptr Bytes
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall (m :: * -> *) a. Monad m => a -> m a
return Bytes
result'
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data InputStreamReadBytesFinishMethodInfo
instance (signature ~ (b -> m GLib.Bytes.Bytes), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod InputStreamReadBytesFinishMethodInfo a signature where
overloadedMethod = inputStreamReadBytesFinish
instance O.OverloadedMethodInfo InputStreamReadBytesFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamReadBytesFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamReadBytesFinish"
})
#endif
foreign import ccall "g_input_stream_read_finish" g_input_stream_read_finish ::
Ptr InputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO Int32
inputStreamReadFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m Int32
inputStreamReadFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
a -> b -> m Int32
inputStreamReadFinish a
stream b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
forall a b. IO a -> IO b -> IO a
onException (do
Int32
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO Int32
g_input_stream_read_finish Ptr InputStream
stream' Ptr AsyncResult
result_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data InputStreamReadFinishMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod InputStreamReadFinishMethodInfo a signature where
overloadedMethod = inputStreamReadFinish
instance O.OverloadedMethodInfo InputStreamReadFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamReadFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamReadFinish"
})
#endif
foreign import ccall "g_input_stream_set_pending" g_input_stream_set_pending ::
Ptr InputStream ->
Ptr (Ptr GError) ->
IO CInt
inputStreamSetPending ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a) =>
a
-> m ()
inputStreamSetPending :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsInputStream a) =>
a -> m ()
inputStreamSetPending a
stream = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream -> Ptr (Ptr GError) -> IO CInt
g_input_stream_set_pending Ptr InputStream
stream'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data InputStreamSetPendingMethodInfo
instance (signature ~ (m ()), MonadIO m, IsInputStream a) => O.OverloadedMethod InputStreamSetPendingMethodInfo a signature where
overloadedMethod = inputStreamSetPending
instance O.OverloadedMethodInfo InputStreamSetPendingMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamSetPending",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamSetPending"
})
#endif
foreign import ccall "g_input_stream_skip" g_input_stream_skip ::
Ptr InputStream ->
Word32 ->
Ptr Gio.Cancellable.Cancellable ->
Ptr (Ptr GError) ->
IO Int32
inputStreamSkip ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Word32
-> Maybe (b)
-> m Int32
inputStreamSkip :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> Word32 -> Maybe b -> m Int32
inputStreamSkip a
stream Word32
count Maybe b
cancellable = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
forall a b. IO a -> IO b -> IO a
onException (do
Int32
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream
-> Word32 -> Ptr Cancellable -> Ptr (Ptr GError) -> IO Int32
g_input_stream_skip Ptr InputStream
stream' Word32
count Ptr Cancellable
maybeCancellable
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data InputStreamSkipMethodInfo
instance (signature ~ (Word32 -> Maybe (b) -> m Int32), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamSkipMethodInfo a signature where
overloadedMethod = inputStreamSkip
instance O.OverloadedMethodInfo InputStreamSkipMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamSkip",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamSkip"
})
#endif
foreign import ccall "g_input_stream_skip_async" g_input_stream_skip_async ::
Ptr InputStream ->
Word32 ->
Int32 ->
Ptr Gio.Cancellable.Cancellable ->
FunPtr Gio.Callbacks.C_AsyncReadyCallback ->
Ptr () ->
IO ()
inputStreamSkipAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) =>
a
-> Word32
-> Int32
-> Maybe (b)
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
-> m ()
inputStreamSkipAsync :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
a -> Word32 -> Int32 -> Maybe b -> Maybe AsyncReadyCallback -> m ()
inputStreamSkipAsync a
stream Word32
count Int32
ioPriority Maybe b
cancellable Maybe AsyncReadyCallback
callback = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr Cancellable
maybeCancellable <- case Maybe b
cancellable of
Maybe b
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Ptr a
nullPtr
Just b
jCancellable -> do
Ptr Cancellable
jCancellable' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
jCancellable
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr Cancellable
jCancellable'
FunPtr C_AsyncReadyCallback
maybeCallback <- case Maybe AsyncReadyCallback
callback of
Maybe AsyncReadyCallback
Nothing -> forall (m :: * -> *) a. Monad m => a -> m a
return (forall a b. Ptr a -> FunPtr b
castPtrToFunPtr forall a. Ptr a
nullPtr)
Just AsyncReadyCallback
jCallback -> do
Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback <- forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
FunPtr C_AsyncReadyCallback
jCallback' <- C_AsyncReadyCallback -> IO (FunPtr C_AsyncReadyCallback)
Gio.Callbacks.mk_AsyncReadyCallback (Maybe (Ptr (FunPtr C_AsyncReadyCallback))
-> AsyncReadyCallback -> C_AsyncReadyCallback
Gio.Callbacks.wrap_AsyncReadyCallback (forall a. a -> Maybe a
Just Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback) AsyncReadyCallback
jCallback)
forall a. Storable a => Ptr a -> a -> IO ()
poke Ptr (FunPtr C_AsyncReadyCallback)
ptrcallback FunPtr C_AsyncReadyCallback
jCallback'
forall (m :: * -> *) a. Monad m => a -> m a
return FunPtr C_AsyncReadyCallback
jCallback'
let userData :: Ptr a
userData = forall a. Ptr a
nullPtr
Ptr InputStream
-> Word32
-> Int32
-> Ptr Cancellable
-> FunPtr C_AsyncReadyCallback
-> Ptr ()
-> IO ()
g_input_stream_skip_async Ptr InputStream
stream' Word32
count Int32
ioPriority Ptr Cancellable
maybeCancellable FunPtr C_AsyncReadyCallback
maybeCallback forall a. Ptr a
userData
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall (m :: * -> *) a. Monad m => Maybe a -> (a -> m ()) -> m ()
whenJust Maybe b
cancellable forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data InputStreamSkipAsyncMethodInfo
instance (signature ~ (Word32 -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsInputStream a, Gio.Cancellable.IsCancellable b) => O.OverloadedMethod InputStreamSkipAsyncMethodInfo a signature where
overloadedMethod = inputStreamSkipAsync
instance O.OverloadedMethodInfo InputStreamSkipAsyncMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamSkipAsync",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamSkipAsync"
})
#endif
foreign import ccall "g_input_stream_skip_finish" g_input_stream_skip_finish ::
Ptr InputStream ->
Ptr Gio.AsyncResult.AsyncResult ->
Ptr (Ptr GError) ->
IO Int32
inputStreamSkipFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) =>
a
-> b
-> m Int32
inputStreamSkipFinish :: forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
a -> b -> m Int32
inputStreamSkipFinish a
stream b
result_ = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr InputStream
stream' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
stream
Ptr AsyncResult
result_' <- forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr b
result_
forall a b. IO a -> IO b -> IO a
onException (do
Int32
result <- forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError forall a b. (a -> b) -> a -> b
$ Ptr InputStream -> Ptr AsyncResult -> Ptr (Ptr GError) -> IO Int32
g_input_stream_skip_finish Ptr InputStream
stream' Ptr AsyncResult
result_'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
stream
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr b
result_
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
) (do
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
#if defined(ENABLE_OVERLOADING)
data InputStreamSkipFinishMethodInfo
instance (signature ~ (b -> m Int32), MonadIO m, IsInputStream a, Gio.AsyncResult.IsAsyncResult b) => O.OverloadedMethod InputStreamSkipFinishMethodInfo a signature where
overloadedMethod = inputStreamSkipFinish
instance O.OverloadedMethodInfo InputStreamSkipFinishMethodInfo a where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Objects.InputStream.inputStreamSkipFinish",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Objects-InputStream.html#v:inputStreamSkipFinish"
})
#endif