{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Structs.InputStreamClass
(
InputStreamClass(..) ,
newZeroInputStreamClass ,
#if defined(ENABLE_OVERLOADING)
ResolveInputStreamClassMethod ,
#endif
clearInputStreamClassCloseAsync ,
getInputStreamClassCloseAsync ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_closeAsync ,
#endif
setInputStreamClassCloseAsync ,
clearInputStreamClassCloseFinish ,
getInputStreamClassCloseFinish ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_closeFinish ,
#endif
setInputStreamClassCloseFinish ,
clearInputStreamClassCloseFn ,
getInputStreamClassCloseFn ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_closeFn ,
#endif
setInputStreamClassCloseFn ,
getInputStreamClassParentClass ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_parentClass ,
#endif
clearInputStreamClassReadAsync ,
getInputStreamClassReadAsync ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_readAsync ,
#endif
setInputStreamClassReadAsync ,
clearInputStreamClassReadFinish ,
getInputStreamClassReadFinish ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_readFinish ,
#endif
setInputStreamClassReadFinish ,
clearInputStreamClassReadFn ,
getInputStreamClassReadFn ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_readFn ,
#endif
setInputStreamClassReadFn ,
clearInputStreamClassSkip ,
getInputStreamClassSkip ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_skip ,
#endif
setInputStreamClassSkip ,
clearInputStreamClassSkipAsync ,
getInputStreamClassSkipAsync ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_skipAsync ,
#endif
setInputStreamClassSkipAsync ,
clearInputStreamClassSkipFinish ,
getInputStreamClassSkipFinish ,
#if defined(ENABLE_OVERLOADING)
inputStreamClass_skipFinish ,
#endif
setInputStreamClassSkipFinish ,
) 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.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Gio.Callbacks as Gio.Callbacks
#else
import qualified GI.GObject.Structs.ObjectClass as GObject.ObjectClass
import qualified GI.Gio.Callbacks as Gio.Callbacks
#endif
newtype InputStreamClass = InputStreamClass (SP.ManagedPtr InputStreamClass)
deriving (InputStreamClass -> InputStreamClass -> Bool
(InputStreamClass -> InputStreamClass -> Bool)
-> (InputStreamClass -> InputStreamClass -> Bool)
-> Eq InputStreamClass
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: InputStreamClass -> InputStreamClass -> Bool
== :: InputStreamClass -> InputStreamClass -> Bool
$c/= :: InputStreamClass -> InputStreamClass -> Bool
/= :: InputStreamClass -> InputStreamClass -> Bool
Eq)
instance SP.ManagedPtrNewtype InputStreamClass where
toManagedPtr :: InputStreamClass -> ManagedPtr InputStreamClass
toManagedPtr (InputStreamClass ManagedPtr InputStreamClass
p) = ManagedPtr InputStreamClass
p
instance BoxedPtr InputStreamClass where
boxedPtrCopy :: InputStreamClass -> IO InputStreamClass
boxedPtrCopy = \InputStreamClass
p -> InputStreamClass
-> (Ptr InputStreamClass -> IO InputStreamClass)
-> IO InputStreamClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr InputStreamClass
p (Int -> Ptr InputStreamClass -> IO (Ptr InputStreamClass)
forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
248 (Ptr InputStreamClass -> IO (Ptr InputStreamClass))
-> (Ptr InputStreamClass -> IO InputStreamClass)
-> Ptr InputStreamClass
-> IO InputStreamClass
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr InputStreamClass -> InputStreamClass)
-> Ptr InputStreamClass -> IO InputStreamClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr InputStreamClass -> InputStreamClass
InputStreamClass)
boxedPtrFree :: InputStreamClass -> IO ()
boxedPtrFree = \InputStreamClass
x -> InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr InputStreamClass
x Ptr InputStreamClass -> IO ()
forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr InputStreamClass where
boxedPtrCalloc :: IO (Ptr InputStreamClass)
boxedPtrCalloc = Int -> IO (Ptr InputStreamClass)
forall a. Int -> IO (Ptr a)
callocBytes Int
248
newZeroInputStreamClass :: MonadIO m => m InputStreamClass
newZeroInputStreamClass :: forall (m :: * -> *). MonadIO m => m InputStreamClass
newZeroInputStreamClass = IO InputStreamClass -> m InputStreamClass
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InputStreamClass -> m InputStreamClass)
-> IO InputStreamClass -> m InputStreamClass
forall a b. (a -> b) -> a -> b
$ IO (Ptr InputStreamClass)
forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc IO (Ptr InputStreamClass)
-> (Ptr InputStreamClass -> IO InputStreamClass)
-> IO InputStreamClass
forall a b. IO a -> (a -> IO b) -> IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr InputStreamClass -> InputStreamClass)
-> Ptr InputStreamClass -> IO InputStreamClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr InputStreamClass -> InputStreamClass
InputStreamClass
instance tag ~ 'AttrSet => Constructible InputStreamClass tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr InputStreamClass -> InputStreamClass)
-> [AttrOp InputStreamClass tag] -> m InputStreamClass
new ManagedPtr InputStreamClass -> InputStreamClass
_ [AttrOp InputStreamClass tag]
attrs = do
o <- m InputStreamClass
forall (m :: * -> *). MonadIO m => m InputStreamClass
newZeroInputStreamClass
GI.Attributes.set o attrs
return o
getInputStreamClassParentClass :: MonadIO m => InputStreamClass -> m GObject.ObjectClass.ObjectClass
getInputStreamClassParentClass :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass -> m ObjectClass
getInputStreamClassParentClass InputStreamClass
s = IO ObjectClass -> m ObjectClass
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ObjectClass -> m ObjectClass)
-> IO ObjectClass -> m ObjectClass
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass -> IO ObjectClass) -> IO ObjectClass
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ObjectClass) -> IO ObjectClass)
-> (Ptr InputStreamClass -> IO ObjectClass) -> IO ObjectClass
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
let val :: Ptr ObjectClass
val = Ptr InputStreamClass
ptr Ptr InputStreamClass -> Int -> Ptr ObjectClass
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr GObject.ObjectClass.ObjectClass)
val' <- ((ManagedPtr ObjectClass -> ObjectClass)
-> Ptr ObjectClass -> IO ObjectClass
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr ObjectClass -> ObjectClass
GObject.ObjectClass.ObjectClass) Ptr ObjectClass
val
return val'
#if defined(ENABLE_OVERLOADING)
data InputStreamClassParentClassFieldInfo
instance AttrInfo InputStreamClassParentClassFieldInfo where
type AttrBaseTypeConstraint InputStreamClassParentClassFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassParentClassFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint InputStreamClassParentClassFieldInfo = (~) (Ptr GObject.ObjectClass.ObjectClass)
type AttrTransferTypeConstraint InputStreamClassParentClassFieldInfo = (~)(Ptr GObject.ObjectClass.ObjectClass)
type AttrTransferType InputStreamClassParentClassFieldInfo = (Ptr GObject.ObjectClass.ObjectClass)
type AttrGetType InputStreamClassParentClassFieldInfo = GObject.ObjectClass.ObjectClass
type AttrLabel InputStreamClassParentClassFieldInfo = "parent_class"
type AttrOrigin InputStreamClassParentClassFieldInfo = InputStreamClass
attrGet = getInputStreamClassParentClass
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.parentClass"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:parentClass"
})
inputStreamClass_parentClass :: AttrLabelProxy "parentClass"
inputStreamClass_parentClass = AttrLabelProxy
#endif
getInputStreamClassReadFn :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassReadFnFieldCallback)
getInputStreamClassReadFn :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass -> m (Maybe InputStreamClassReadFnFieldCallback)
getInputStreamClassReadFn InputStreamClass
s = IO (Maybe InputStreamClassReadFnFieldCallback)
-> m (Maybe InputStreamClassReadFnFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassReadFnFieldCallback)
-> m (Maybe InputStreamClassReadFnFieldCallback))
-> IO (Maybe InputStreamClassReadFnFieldCallback)
-> m (Maybe InputStreamClassReadFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFnFieldCallback))
-> IO (Maybe InputStreamClassReadFnFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFnFieldCallback))
-> IO (Maybe InputStreamClassReadFnFieldCallback))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFnFieldCallback))
-> IO (Maybe InputStreamClassReadFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
-> IO (FunPtr C_InputStreamClassReadFnFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassReadFnFieldCallback
val' -> do
let val'' :: InputStreamClassReadFnFieldCallback
val'' = FunPtr C_InputStreamClassReadFnFieldCallback
-> InputStreamClassReadFnFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassReadFnFieldCallback
-> a -> Ptr () -> CSize -> Maybe b -> m Int64
Gio.Callbacks.dynamic_InputStreamClassReadFnFieldCallback FunPtr C_InputStreamClassReadFnFieldCallback
val'
InputStreamClassReadFnFieldCallback
-> IO InputStreamClassReadFnFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassReadFnFieldCallback
val''
return result
setInputStreamClassReadFn :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback -> m ()
setInputStreamClassReadFn :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassReadFnFieldCallback -> m ()
setInputStreamClassReadFn InputStreamClass
s FunPtr C_InputStreamClassReadFnFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
-> FunPtr C_InputStreamClassReadFnFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_InputStreamClassReadFnFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
clearInputStreamClassReadFn :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassReadFn :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassReadFn InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
-> FunPtr C_InputStreamClassReadFnFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
136) (FunPtr C_InputStreamClassReadFnFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassReadFnFieldInfo
instance AttrInfo InputStreamClassReadFnFieldInfo where
type AttrBaseTypeConstraint InputStreamClassReadFnFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassReadFnFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassReadFnFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
type AttrTransferTypeConstraint InputStreamClassReadFnFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
type AttrTransferType InputStreamClassReadFnFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassReadFnFieldCallback)
type AttrGetType InputStreamClassReadFnFieldInfo = Maybe Gio.Callbacks.InputStreamClassReadFnFieldCallback
type AttrLabel InputStreamClassReadFnFieldInfo = "read_fn"
type AttrOrigin InputStreamClassReadFnFieldInfo = InputStreamClass
attrGet = getInputStreamClassReadFn
attrSet = setInputStreamClassReadFn
attrConstruct = undefined
attrClear = clearInputStreamClassReadFn
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.readFn"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readFn"
})
inputStreamClass_readFn :: AttrLabelProxy "readFn"
inputStreamClass_readFn = AttrLabelProxy
#endif
getInputStreamClassSkip :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassSkipFieldCallback)
getInputStreamClassSkip :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass -> m (Maybe InputStreamClassSkipFieldCallback)
getInputStreamClassSkip InputStreamClass
s = IO (Maybe InputStreamClassSkipFieldCallback)
-> m (Maybe InputStreamClassSkipFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassSkipFieldCallback)
-> m (Maybe InputStreamClassSkipFieldCallback))
-> IO (Maybe InputStreamClassSkipFieldCallback)
-> m (Maybe InputStreamClassSkipFieldCallback)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassSkipFieldCallback))
-> IO (Maybe InputStreamClassSkipFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassSkipFieldCallback))
-> IO (Maybe InputStreamClassSkipFieldCallback))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassSkipFieldCallback))
-> IO (Maybe InputStreamClassSkipFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
-> IO (FunPtr C_InputStreamClassSkipFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassSkipFieldCallback
val' -> do
let val'' :: InputStreamClassSkipFieldCallback
val'' = FunPtr C_InputStreamClassSkipFieldCallback
-> InputStreamClassSkipFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassSkipFieldCallback
-> a -> CSize -> Maybe b -> m Int64
Gio.Callbacks.dynamic_InputStreamClassSkipFieldCallback FunPtr C_InputStreamClassSkipFieldCallback
val'
InputStreamClassSkipFieldCallback
-> IO InputStreamClassSkipFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassSkipFieldCallback
val''
return result
setInputStreamClassSkip :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback -> m ()
setInputStreamClassSkip :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassSkipFieldCallback -> m ()
setInputStreamClassSkip InputStreamClass
s FunPtr C_InputStreamClassSkipFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
-> FunPtr C_InputStreamClassSkipFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_InputStreamClassSkipFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
clearInputStreamClassSkip :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassSkip :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassSkip InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
-> FunPtr C_InputStreamClassSkipFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassSkipFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
144) (FunPtr C_InputStreamClassSkipFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassSkipFieldInfo
instance AttrInfo InputStreamClassSkipFieldInfo where
type AttrBaseTypeConstraint InputStreamClassSkipFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassSkipFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassSkipFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
type AttrTransferTypeConstraint InputStreamClassSkipFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
type AttrTransferType InputStreamClassSkipFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassSkipFieldCallback)
type AttrGetType InputStreamClassSkipFieldInfo = Maybe Gio.Callbacks.InputStreamClassSkipFieldCallback
type AttrLabel InputStreamClassSkipFieldInfo = "skip"
type AttrOrigin InputStreamClassSkipFieldInfo = InputStreamClass
attrGet = getInputStreamClassSkip
attrSet = setInputStreamClassSkip
attrConstruct = undefined
attrClear = clearInputStreamClassSkip
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.skip"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skip"
})
inputStreamClass_skip :: AttrLabelProxy "skip"
inputStreamClass_skip = AttrLabelProxy
#endif
getInputStreamClassCloseFn :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassCloseFnFieldCallback)
getInputStreamClassCloseFn :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass -> m (Maybe InputStreamClassCloseFnFieldCallback)
getInputStreamClassCloseFn InputStreamClass
s = IO (Maybe InputStreamClassCloseFnFieldCallback)
-> m (Maybe InputStreamClassCloseFnFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassCloseFnFieldCallback)
-> m (Maybe InputStreamClassCloseFnFieldCallback))
-> IO (Maybe InputStreamClassCloseFnFieldCallback)
-> m (Maybe InputStreamClassCloseFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseFnFieldCallback))
-> IO (Maybe InputStreamClassCloseFnFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseFnFieldCallback))
-> IO (Maybe InputStreamClassCloseFnFieldCallback))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseFnFieldCallback))
-> IO (Maybe InputStreamClassCloseFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
-> IO (FunPtr C_InputStreamClassCloseFnFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassCloseFnFieldCallback
val' -> do
let val'' :: InputStreamClassCloseFnFieldCallback
val'' = FunPtr C_InputStreamClassCloseFnFieldCallback
-> InputStreamClassCloseFnFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassCloseFnFieldCallback
-> a -> Maybe b -> m ()
Gio.Callbacks.dynamic_InputStreamClassCloseFnFieldCallback FunPtr C_InputStreamClassCloseFnFieldCallback
val'
InputStreamClassCloseFnFieldCallback
-> IO InputStreamClassCloseFnFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassCloseFnFieldCallback
val''
return result
setInputStreamClassCloseFn :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback -> m ()
setInputStreamClassCloseFn :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassCloseFnFieldCallback -> m ()
setInputStreamClassCloseFn InputStreamClass
s FunPtr C_InputStreamClassCloseFnFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
-> FunPtr C_InputStreamClassCloseFnFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (FunPtr C_InputStreamClassCloseFnFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
clearInputStreamClassCloseFn :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassCloseFn :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassCloseFn InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
-> FunPtr C_InputStreamClassCloseFnFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseFnFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
152) (FunPtr C_InputStreamClassCloseFnFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassCloseFnFieldInfo
instance AttrInfo InputStreamClassCloseFnFieldInfo where
type AttrBaseTypeConstraint InputStreamClassCloseFnFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassCloseFnFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassCloseFnFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
type AttrTransferTypeConstraint InputStreamClassCloseFnFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
type AttrTransferType InputStreamClassCloseFnFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassCloseFnFieldCallback)
type AttrGetType InputStreamClassCloseFnFieldInfo = Maybe Gio.Callbacks.InputStreamClassCloseFnFieldCallback
type AttrLabel InputStreamClassCloseFnFieldInfo = "close_fn"
type AttrOrigin InputStreamClassCloseFnFieldInfo = InputStreamClass
attrGet = getInputStreamClassCloseFn
attrSet = setInputStreamClassCloseFn
attrConstruct = undefined
attrClear = clearInputStreamClassCloseFn
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.closeFn"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:closeFn"
})
inputStreamClass_closeFn :: AttrLabelProxy "closeFn"
inputStreamClass_closeFn = AttrLabelProxy
#endif
getInputStreamClassReadAsync :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassReadAsyncFieldCallback_WithClosures)
getInputStreamClassReadAsync :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> m (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
getInputStreamClassReadAsync InputStreamClass
s = IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
-> IO (FunPtr C_InputStreamClassReadAsyncFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassReadAsyncFieldCallback
val' -> do
let val'' :: InputStreamClassReadAsyncFieldCallback_WithClosures
val'' = FunPtr C_InputStreamClassReadAsyncFieldCallback
-> InputStreamClassReadAsyncFieldCallback_WithClosures
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassReadAsyncFieldCallback
-> a
-> Maybe ByteString
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback_WithClosures
-> Ptr ()
-> m (Maybe ByteString)
Gio.Callbacks.dynamic_InputStreamClassReadAsyncFieldCallback FunPtr C_InputStreamClassReadAsyncFieldCallback
val'
InputStreamClassReadAsyncFieldCallback_WithClosures
-> IO InputStreamClassReadAsyncFieldCallback_WithClosures
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassReadAsyncFieldCallback_WithClosures
val''
return result
setInputStreamClassReadAsync :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback -> m ()
setInputStreamClassReadAsync :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassReadAsyncFieldCallback -> m ()
setInputStreamClassReadAsync InputStreamClass
s FunPtr C_InputStreamClassReadAsyncFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
-> FunPtr C_InputStreamClassReadAsyncFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_InputStreamClassReadAsyncFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)
clearInputStreamClassReadAsync :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassReadAsync :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassReadAsync InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
-> FunPtr C_InputStreamClassReadAsyncFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
160) (FunPtr C_InputStreamClassReadAsyncFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassReadAsyncFieldInfo
instance AttrInfo InputStreamClassReadAsyncFieldInfo where
type AttrBaseTypeConstraint InputStreamClassReadAsyncFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassReadAsyncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassReadAsyncFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)
type AttrTransferTypeConstraint InputStreamClassReadAsyncFieldInfo = (~)Gio.Callbacks.InputStreamClassReadAsyncFieldCallback_WithClosures
type AttrTransferType InputStreamClassReadAsyncFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassReadAsyncFieldCallback)
type AttrGetType InputStreamClassReadAsyncFieldInfo = Maybe Gio.Callbacks.InputStreamClassReadAsyncFieldCallback_WithClosures
type AttrLabel InputStreamClassReadAsyncFieldInfo = "read_async"
type AttrOrigin InputStreamClassReadAsyncFieldInfo = InputStreamClass
attrGet = getInputStreamClassReadAsync
attrSet = setInputStreamClassReadAsync
attrConstruct = undefined
attrClear = clearInputStreamClassReadAsync
attrTransfer _ v = do
Gio.Callbacks.mk_InputStreamClassReadAsyncFieldCallback (Gio.Callbacks.wrap_InputStreamClassReadAsyncFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.readAsync"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readAsync"
})
inputStreamClass_readAsync :: AttrLabelProxy "readAsync"
inputStreamClass_readAsync = AttrLabelProxy
#endif
getInputStreamClassReadFinish :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassReadFinishFieldCallback)
getInputStreamClassReadFinish :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> m (Maybe InputStreamClassReadFinishFieldCallback)
getInputStreamClassReadFinish InputStreamClass
s = IO (Maybe InputStreamClassReadFinishFieldCallback)
-> m (Maybe InputStreamClassReadFinishFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassReadFinishFieldCallback)
-> m (Maybe InputStreamClassReadFinishFieldCallback))
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
-> m (Maybe InputStreamClassReadFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
-> IO (FunPtr C_InputStreamClassReadFinishFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassReadFinishFieldCallback
val' -> do
let val'' :: InputStreamClassReadFinishFieldCallback
val'' = FunPtr C_InputStreamClassReadFinishFieldCallback
-> InputStreamClassReadFinishFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
FunPtr C_InputStreamClassReadFinishFieldCallback
-> a -> b -> m Int64
Gio.Callbacks.dynamic_InputStreamClassReadFinishFieldCallback FunPtr C_InputStreamClassReadFinishFieldCallback
val'
InputStreamClassReadFinishFieldCallback
-> IO InputStreamClassReadFinishFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassReadFinishFieldCallback
val''
return result
setInputStreamClassReadFinish :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback -> m ()
setInputStreamClassReadFinish :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassReadFinishFieldCallback -> m ()
setInputStreamClassReadFinish InputStreamClass
s FunPtr C_InputStreamClassReadFinishFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
-> FunPtr C_InputStreamClassReadFinishFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_InputStreamClassReadFinishFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
clearInputStreamClassReadFinish :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassReadFinish :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassReadFinish InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
-> FunPtr C_InputStreamClassReadFinishFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
168) (FunPtr C_InputStreamClassReadFinishFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassReadFinishFieldInfo
instance AttrInfo InputStreamClassReadFinishFieldInfo where
type AttrBaseTypeConstraint InputStreamClassReadFinishFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassReadFinishFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassReadFinishFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
type AttrTransferTypeConstraint InputStreamClassReadFinishFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
type AttrTransferType InputStreamClassReadFinishFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassReadFinishFieldCallback)
type AttrGetType InputStreamClassReadFinishFieldInfo = Maybe Gio.Callbacks.InputStreamClassReadFinishFieldCallback
type AttrLabel InputStreamClassReadFinishFieldInfo = "read_finish"
type AttrOrigin InputStreamClassReadFinishFieldInfo = InputStreamClass
attrGet = getInputStreamClassReadFinish
attrSet = setInputStreamClassReadFinish
attrConstruct = undefined
attrClear = clearInputStreamClassReadFinish
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.readFinish"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readFinish"
})
inputStreamClass_readFinish :: AttrLabelProxy "readFinish"
inputStreamClass_readFinish = AttrLabelProxy
#endif
getInputStreamClassSkipAsync :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassSkipAsyncFieldCallback_WithClosures)
getInputStreamClassSkipAsync :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> m (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
getInputStreamClassSkipAsync InputStreamClass
s = IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
-> IO (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassSkipAsyncFieldCallback
val' -> do
let val'' :: InputStreamClassSkipAsyncFieldCallback_WithClosures
val'' = FunPtr C_InputStreamClassSkipAsyncFieldCallback
-> InputStreamClassSkipAsyncFieldCallback_WithClosures
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassSkipAsyncFieldCallback
-> a
-> CSize
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback_WithClosures
-> Ptr ()
-> m ()
Gio.Callbacks.dynamic_InputStreamClassSkipAsyncFieldCallback FunPtr C_InputStreamClassSkipAsyncFieldCallback
val'
InputStreamClassSkipAsyncFieldCallback_WithClosures
-> IO InputStreamClassSkipAsyncFieldCallback_WithClosures
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassSkipAsyncFieldCallback_WithClosures
val''
return result
setInputStreamClassSkipAsync :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback -> m ()
setInputStreamClassSkipAsync :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassSkipAsyncFieldCallback -> m ()
setInputStreamClassSkipAsync InputStreamClass
s FunPtr C_InputStreamClassSkipAsyncFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
-> FunPtr C_InputStreamClassSkipAsyncFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_InputStreamClassSkipAsyncFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)
clearInputStreamClassSkipAsync :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassSkipAsync :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassSkipAsync InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
-> FunPtr C_InputStreamClassSkipAsyncFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassSkipAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
176) (FunPtr C_InputStreamClassSkipAsyncFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassSkipAsyncFieldInfo
instance AttrInfo InputStreamClassSkipAsyncFieldInfo where
type AttrBaseTypeConstraint InputStreamClassSkipAsyncFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassSkipAsyncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassSkipAsyncFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)
type AttrTransferTypeConstraint InputStreamClassSkipAsyncFieldInfo = (~)Gio.Callbacks.InputStreamClassSkipAsyncFieldCallback_WithClosures
type AttrTransferType InputStreamClassSkipAsyncFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassSkipAsyncFieldCallback)
type AttrGetType InputStreamClassSkipAsyncFieldInfo = Maybe Gio.Callbacks.InputStreamClassSkipAsyncFieldCallback_WithClosures
type AttrLabel InputStreamClassSkipAsyncFieldInfo = "skip_async"
type AttrOrigin InputStreamClassSkipAsyncFieldInfo = InputStreamClass
attrGet = getInputStreamClassSkipAsync
attrSet = setInputStreamClassSkipAsync
attrConstruct = undefined
attrClear = clearInputStreamClassSkipAsync
attrTransfer _ v = do
Gio.Callbacks.mk_InputStreamClassSkipAsyncFieldCallback (Gio.Callbacks.wrap_InputStreamClassSkipAsyncFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.skipAsync"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skipAsync"
})
inputStreamClass_skipAsync :: AttrLabelProxy "skipAsync"
inputStreamClass_skipAsync = AttrLabelProxy
#endif
getInputStreamClassSkipFinish :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassSkipFinishFieldCallback)
getInputStreamClassSkipFinish :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> m (Maybe InputStreamClassReadFinishFieldCallback)
getInputStreamClassSkipFinish InputStreamClass
s = IO (Maybe InputStreamClassReadFinishFieldCallback)
-> m (Maybe InputStreamClassReadFinishFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassReadFinishFieldCallback)
-> m (Maybe InputStreamClassReadFinishFieldCallback))
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
-> m (Maybe InputStreamClassReadFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
-> IO (FunPtr C_InputStreamClassReadFinishFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassReadFinishFieldCallback
val' -> do
let val'' :: InputStreamClassReadFinishFieldCallback
val'' = FunPtr C_InputStreamClassReadFinishFieldCallback
-> InputStreamClassReadFinishFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
FunPtr C_InputStreamClassReadFinishFieldCallback
-> a -> b -> m Int64
Gio.Callbacks.dynamic_InputStreamClassSkipFinishFieldCallback FunPtr C_InputStreamClassReadFinishFieldCallback
val'
InputStreamClassReadFinishFieldCallback
-> IO InputStreamClassReadFinishFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassReadFinishFieldCallback
val''
return result
setInputStreamClassSkipFinish :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback -> m ()
setInputStreamClassSkipFinish :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassReadFinishFieldCallback -> m ()
setInputStreamClassSkipFinish InputStreamClass
s FunPtr C_InputStreamClassReadFinishFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
-> FunPtr C_InputStreamClassReadFinishFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_InputStreamClassReadFinishFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
clearInputStreamClassSkipFinish :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassSkipFinish :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassSkipFinish InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
-> FunPtr C_InputStreamClassReadFinishFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassReadFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
184) (FunPtr C_InputStreamClassReadFinishFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassSkipFinishFieldInfo
instance AttrInfo InputStreamClassSkipFinishFieldInfo where
type AttrBaseTypeConstraint InputStreamClassSkipFinishFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassSkipFinishFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassSkipFinishFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
type AttrTransferTypeConstraint InputStreamClassSkipFinishFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
type AttrTransferType InputStreamClassSkipFinishFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassSkipFinishFieldCallback)
type AttrGetType InputStreamClassSkipFinishFieldInfo = Maybe Gio.Callbacks.InputStreamClassSkipFinishFieldCallback
type AttrLabel InputStreamClassSkipFinishFieldInfo = "skip_finish"
type AttrOrigin InputStreamClassSkipFinishFieldInfo = InputStreamClass
attrGet = getInputStreamClassSkipFinish
attrSet = setInputStreamClassSkipFinish
attrConstruct = undefined
attrClear = clearInputStreamClassSkipFinish
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.skipFinish"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skipFinish"
})
inputStreamClass_skipFinish :: AttrLabelProxy "skipFinish"
inputStreamClass_skipFinish = AttrLabelProxy
#endif
getInputStreamClassCloseAsync :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassCloseAsyncFieldCallback_WithClosures)
getInputStreamClassCloseAsync :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> m (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
getInputStreamClassCloseAsync InputStreamClass
s = IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
-> m (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
-> IO (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassCloseAsyncFieldCallback
val' -> do
let val'' :: InputStreamClassCloseAsyncFieldCallback_WithClosures
val'' = FunPtr C_InputStreamClassCloseAsyncFieldCallback
-> InputStreamClassCloseAsyncFieldCallback_WithClosures
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsCancellable b) =>
FunPtr C_InputStreamClassCloseAsyncFieldCallback
-> a
-> Int32
-> Maybe b
-> Maybe AsyncReadyCallback_WithClosures
-> Ptr ()
-> m ()
Gio.Callbacks.dynamic_InputStreamClassCloseAsyncFieldCallback FunPtr C_InputStreamClassCloseAsyncFieldCallback
val'
InputStreamClassCloseAsyncFieldCallback_WithClosures
-> IO InputStreamClassCloseAsyncFieldCallback_WithClosures
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassCloseAsyncFieldCallback_WithClosures
val''
return result
setInputStreamClassCloseAsync :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback -> m ()
setInputStreamClassCloseAsync :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassCloseAsyncFieldCallback -> m ()
setInputStreamClassCloseAsync InputStreamClass
s FunPtr C_InputStreamClassCloseAsyncFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
-> FunPtr C_InputStreamClassCloseAsyncFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_InputStreamClassCloseAsyncFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)
clearInputStreamClassCloseAsync :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassCloseAsync :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassCloseAsync InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
-> FunPtr C_InputStreamClassCloseAsyncFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseAsyncFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
192) (FunPtr C_InputStreamClassCloseAsyncFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassCloseAsyncFieldInfo
instance AttrInfo InputStreamClassCloseAsyncFieldInfo where
type AttrBaseTypeConstraint InputStreamClassCloseAsyncFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassCloseAsyncFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassCloseAsyncFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)
type AttrTransferTypeConstraint InputStreamClassCloseAsyncFieldInfo = (~)Gio.Callbacks.InputStreamClassCloseAsyncFieldCallback_WithClosures
type AttrTransferType InputStreamClassCloseAsyncFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassCloseAsyncFieldCallback)
type AttrGetType InputStreamClassCloseAsyncFieldInfo = Maybe Gio.Callbacks.InputStreamClassCloseAsyncFieldCallback_WithClosures
type AttrLabel InputStreamClassCloseAsyncFieldInfo = "close_async"
type AttrOrigin InputStreamClassCloseAsyncFieldInfo = InputStreamClass
attrGet = getInputStreamClassCloseAsync
attrSet = setInputStreamClassCloseAsync
attrConstruct = undefined
attrClear = clearInputStreamClassCloseAsync
attrTransfer _ v = do
Gio.Callbacks.mk_InputStreamClassCloseAsyncFieldCallback (Gio.Callbacks.wrap_InputStreamClassCloseAsyncFieldCallback Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.closeAsync"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:closeAsync"
})
inputStreamClass_closeAsync :: AttrLabelProxy "closeAsync"
inputStreamClass_closeAsync = AttrLabelProxy
#endif
getInputStreamClassCloseFinish :: MonadIO m => InputStreamClass -> m (Maybe Gio.Callbacks.InputStreamClassCloseFinishFieldCallback)
getInputStreamClassCloseFinish :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> m (Maybe InputStreamClassCloseFinishFieldCallback)
getInputStreamClassCloseFinish InputStreamClass
s = IO (Maybe InputStreamClassCloseFinishFieldCallback)
-> m (Maybe InputStreamClassCloseFinishFieldCallback)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe InputStreamClassCloseFinishFieldCallback)
-> m (Maybe InputStreamClassCloseFinishFieldCallback))
-> IO (Maybe InputStreamClassCloseFinishFieldCallback)
-> m (Maybe InputStreamClassCloseFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ InputStreamClass
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseFinishFieldCallback))
-> IO (Maybe InputStreamClassCloseFinishFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseFinishFieldCallback))
-> IO (Maybe InputStreamClassCloseFinishFieldCallback))
-> (Ptr InputStreamClass
-> IO (Maybe InputStreamClassCloseFinishFieldCallback))
-> IO (Maybe InputStreamClassCloseFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
val <- Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
-> IO (FunPtr C_InputStreamClassCloseFinishFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) :: IO (FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
result <- SP.convertFunPtrIfNonNull val $ \FunPtr C_InputStreamClassCloseFinishFieldCallback
val' -> do
let val'' :: InputStreamClassCloseFinishFieldCallback
val'' = FunPtr C_InputStreamClassCloseFinishFieldCallback
-> InputStreamClassCloseFinishFieldCallback
forall (m :: * -> *) a b.
(HasCallStack, MonadIO m, IsInputStream a, IsAsyncResult b) =>
FunPtr C_InputStreamClassCloseFinishFieldCallback -> a -> b -> m ()
Gio.Callbacks.dynamic_InputStreamClassCloseFinishFieldCallback FunPtr C_InputStreamClassCloseFinishFieldCallback
val'
InputStreamClassCloseFinishFieldCallback
-> IO InputStreamClassCloseFinishFieldCallback
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClassCloseFinishFieldCallback
val''
return result
setInputStreamClassCloseFinish :: MonadIO m => InputStreamClass -> FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback -> m ()
setInputStreamClassCloseFinish :: forall (m :: * -> *).
MonadIO m =>
InputStreamClass
-> FunPtr C_InputStreamClassCloseFinishFieldCallback -> m ()
setInputStreamClassCloseFinish InputStreamClass
s FunPtr C_InputStreamClassCloseFinishFieldCallback
val = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
-> FunPtr C_InputStreamClassCloseFinishFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_InputStreamClassCloseFinishFieldCallback
val :: FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
clearInputStreamClassCloseFinish :: MonadIO m => InputStreamClass -> m ()
clearInputStreamClassCloseFinish :: forall (m :: * -> *). MonadIO m => InputStreamClass -> m ()
clearInputStreamClassCloseFinish InputStreamClass
s = 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
$ InputStreamClass -> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr InputStreamClass
s ((Ptr InputStreamClass -> IO ()) -> IO ())
-> (Ptr InputStreamClass -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \Ptr InputStreamClass
ptr -> do
Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
-> FunPtr C_InputStreamClassCloseFinishFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr InputStreamClass
ptr Ptr InputStreamClass
-> Int -> Ptr (FunPtr C_InputStreamClassCloseFinishFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
200) (FunPtr C_InputStreamClassCloseFinishFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
#if defined(ENABLE_OVERLOADING)
data InputStreamClassCloseFinishFieldInfo
instance AttrInfo InputStreamClassCloseFinishFieldInfo where
type AttrBaseTypeConstraint InputStreamClassCloseFinishFieldInfo = (~) InputStreamClass
type AttrAllowedOps InputStreamClassCloseFinishFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint InputStreamClassCloseFinishFieldInfo = (~) (FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
type AttrTransferTypeConstraint InputStreamClassCloseFinishFieldInfo = (~)(FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
type AttrTransferType InputStreamClassCloseFinishFieldInfo = (FunPtr Gio.Callbacks.C_InputStreamClassCloseFinishFieldCallback)
type AttrGetType InputStreamClassCloseFinishFieldInfo = Maybe Gio.Callbacks.InputStreamClassCloseFinishFieldCallback
type AttrLabel InputStreamClassCloseFinishFieldInfo = "close_finish"
type AttrOrigin InputStreamClassCloseFinishFieldInfo = InputStreamClass
attrGet = getInputStreamClassCloseFinish
attrSet = setInputStreamClassCloseFinish
attrConstruct = undefined
attrClear = clearInputStreamClassCloseFinish
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.InputStreamClass.closeFinish"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.35/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:closeFinish"
})
inputStreamClass_closeFinish :: AttrLabelProxy "closeFinish"
inputStreamClass_closeFinish = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList InputStreamClass
type instance O.AttributeList InputStreamClass = InputStreamClassAttributeList
type InputStreamClassAttributeList = ('[ '("parentClass", InputStreamClassParentClassFieldInfo), '("readFn", InputStreamClassReadFnFieldInfo), '("skip", InputStreamClassSkipFieldInfo), '("closeFn", InputStreamClassCloseFnFieldInfo), '("readAsync", InputStreamClassReadAsyncFieldInfo), '("readFinish", InputStreamClassReadFinishFieldInfo), '("skipAsync", InputStreamClassSkipAsyncFieldInfo), '("skipFinish", InputStreamClassSkipFinishFieldInfo), '("closeAsync", InputStreamClassCloseAsyncFieldInfo), '("closeFinish", InputStreamClassCloseFinishFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveInputStreamClassMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveInputStreamClassMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveInputStreamClassMethod t InputStreamClass, O.OverloadedMethod info InputStreamClass p) => OL.IsLabel t (InputStreamClass -> 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 ~ ResolveInputStreamClassMethod t InputStreamClass, O.OverloadedMethod info InputStreamClass p, R.HasField t InputStreamClass p) => R.HasField t InputStreamClass p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveInputStreamClassMethod t InputStreamClass, O.OverloadedMethodInfo info InputStreamClass) => OL.IsLabel t (O.MethodProxy info InputStreamClass) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif