{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Gio.Structs.InputStreamClass
    ( 

-- * Exported types
    InputStreamClass(..)                    ,
    newZeroInputStreamClass                 ,


 -- * Methods

#if defined(ENABLE_OVERLOADING)
    ResolveInputStreamClassMethod           ,
#endif



 -- * Properties


-- ** closeAsync #attr:closeAsync#
-- | /No description available in the introspection data./

    clearInputStreamClassCloseAsync         ,
    getInputStreamClassCloseAsync           ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_closeAsync             ,
#endif
    setInputStreamClassCloseAsync           ,


-- ** closeFinish #attr:closeFinish#
-- | /No description available in the introspection data./

    clearInputStreamClassCloseFinish        ,
    getInputStreamClassCloseFinish          ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_closeFinish            ,
#endif
    setInputStreamClassCloseFinish          ,


-- ** closeFn #attr:closeFn#
-- | /No description available in the introspection data./

    clearInputStreamClassCloseFn            ,
    getInputStreamClassCloseFn              ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_closeFn                ,
#endif
    setInputStreamClassCloseFn              ,


-- ** parentClass #attr:parentClass#
-- | /No description available in the introspection data./

    getInputStreamClassParentClass          ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_parentClass            ,
#endif


-- ** readAsync #attr:readAsync#
-- | /No description available in the introspection data./

    clearInputStreamClassReadAsync          ,
    getInputStreamClassReadAsync            ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_readAsync              ,
#endif
    setInputStreamClassReadAsync            ,


-- ** readFinish #attr:readFinish#
-- | /No description available in the introspection data./

    clearInputStreamClassReadFinish         ,
    getInputStreamClassReadFinish           ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_readFinish             ,
#endif
    setInputStreamClassReadFinish           ,


-- ** readFn #attr:readFn#
-- | /No description available in the introspection data./

    clearInputStreamClassReadFn             ,
    getInputStreamClassReadFn               ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_readFn                 ,
#endif
    setInputStreamClassReadFn               ,


-- ** skip #attr:skip#
-- | /No description available in the introspection data./

    clearInputStreamClassSkip               ,
    getInputStreamClassSkip                 ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_skip                   ,
#endif
    setInputStreamClassSkip                 ,


-- ** skipAsync #attr:skipAsync#
-- | /No description available in the introspection data./

    clearInputStreamClassSkipAsync          ,
    getInputStreamClassSkipAsync            ,
#if defined(ENABLE_OVERLOADING)
    inputStreamClass_skipAsync              ,
#endif
    setInputStreamClassSkipAsync            ,


-- ** skipFinish #attr:skipFinish#
-- | /No description available in the introspection data./

    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

-- Workaround for https://gitlab.haskell.org/ghc/ghc/-/issues/23392
#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

-- | Memory-managed wrapper type.
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


-- | Construct a `InputStreamClass` struct initialized to zero.
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
        InputStreamClass
o <- m InputStreamClass
forall (m :: * -> *). MonadIO m => m InputStreamClass
newZeroInputStreamClass
        InputStreamClass -> [AttrOp InputStreamClass 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set InputStreamClass
o [AttrOp InputStreamClass tag]
[AttrOp InputStreamClass 'AttrSet]
attrs
        InputStreamClass -> m InputStreamClass
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return InputStreamClass
o


-- | Get the value of the “@parent_class@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #parentClass
-- @
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)
    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
    ObjectClass -> IO ObjectClass
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ObjectClass
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:parentClass"
        })

inputStreamClass_parentClass :: AttrLabelProxy "parentClass"
inputStreamClass_parentClass = AttrLabelProxy

#endif


-- | Get the value of the “@read_fn@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #readFn
-- @
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
    FunPtr C_InputStreamClassReadFnFieldCallback
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)
    Maybe InputStreamClassReadFnFieldCallback
result <- FunPtr C_InputStreamClassReadFnFieldCallback
-> (FunPtr C_InputStreamClassReadFnFieldCallback
    -> IO InputStreamClassReadFnFieldCallback)
-> IO (Maybe InputStreamClassReadFnFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassReadFnFieldCallback
val ((FunPtr C_InputStreamClassReadFnFieldCallback
  -> IO InputStreamClassReadFnFieldCallback)
 -> IO (Maybe InputStreamClassReadFnFieldCallback))
-> (FunPtr C_InputStreamClassReadFnFieldCallback
    -> IO InputStreamClassReadFnFieldCallback)
-> IO (Maybe InputStreamClassReadFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassReadFnFieldCallback
-> IO (Maybe InputStreamClassReadFnFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassReadFnFieldCallback
result

-- | Set the value of the “@read_fn@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #readFn 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@read_fn@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #readFn
-- @
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readFn"
        })

inputStreamClass_readFn :: AttrLabelProxy "readFn"
inputStreamClass_readFn = AttrLabelProxy

#endif


-- | Get the value of the “@skip@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #skip
-- @
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
    FunPtr C_InputStreamClassSkipFieldCallback
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)
    Maybe InputStreamClassSkipFieldCallback
result <- FunPtr C_InputStreamClassSkipFieldCallback
-> (FunPtr C_InputStreamClassSkipFieldCallback
    -> IO InputStreamClassSkipFieldCallback)
-> IO (Maybe InputStreamClassSkipFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassSkipFieldCallback
val ((FunPtr C_InputStreamClassSkipFieldCallback
  -> IO InputStreamClassSkipFieldCallback)
 -> IO (Maybe InputStreamClassSkipFieldCallback))
-> (FunPtr C_InputStreamClassSkipFieldCallback
    -> IO InputStreamClassSkipFieldCallback)
-> IO (Maybe InputStreamClassSkipFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassSkipFieldCallback
-> IO (Maybe InputStreamClassSkipFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassSkipFieldCallback
result

-- | Set the value of the “@skip@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #skip 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@skip@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #skip
-- @
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skip"
        })

inputStreamClass_skip :: AttrLabelProxy "skip"
inputStreamClass_skip = AttrLabelProxy

#endif


-- | Get the value of the “@close_fn@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #closeFn
-- @
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
    FunPtr C_InputStreamClassCloseFnFieldCallback
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)
    Maybe InputStreamClassCloseFnFieldCallback
result <- FunPtr C_InputStreamClassCloseFnFieldCallback
-> (FunPtr C_InputStreamClassCloseFnFieldCallback
    -> IO InputStreamClassCloseFnFieldCallback)
-> IO (Maybe InputStreamClassCloseFnFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassCloseFnFieldCallback
val ((FunPtr C_InputStreamClassCloseFnFieldCallback
  -> IO InputStreamClassCloseFnFieldCallback)
 -> IO (Maybe InputStreamClassCloseFnFieldCallback))
-> (FunPtr C_InputStreamClassCloseFnFieldCallback
    -> IO InputStreamClassCloseFnFieldCallback)
-> IO (Maybe InputStreamClassCloseFnFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassCloseFnFieldCallback
-> IO (Maybe InputStreamClassCloseFnFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassCloseFnFieldCallback
result

-- | Set the value of the “@close_fn@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #closeFn 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@close_fn@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #closeFn
-- @
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:closeFn"
        })

inputStreamClass_closeFn :: AttrLabelProxy "closeFn"
inputStreamClass_closeFn = AttrLabelProxy

#endif


-- | Get the value of the “@read_async@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #readAsync
-- @
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
    FunPtr C_InputStreamClassReadAsyncFieldCallback
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)
    Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
result <- FunPtr C_InputStreamClassReadAsyncFieldCallback
-> (FunPtr C_InputStreamClassReadAsyncFieldCallback
    -> IO InputStreamClassReadAsyncFieldCallback_WithClosures)
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassReadAsyncFieldCallback
val ((FunPtr C_InputStreamClassReadAsyncFieldCallback
  -> IO InputStreamClassReadAsyncFieldCallback_WithClosures)
 -> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures))
-> (FunPtr C_InputStreamClassReadAsyncFieldCallback
    -> IO InputStreamClassReadAsyncFieldCallback_WithClosures)
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
-> IO (Maybe InputStreamClassReadAsyncFieldCallback_WithClosures)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassReadAsyncFieldCallback_WithClosures
result

-- | Set the value of the “@read_async@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #readAsync 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@read_async@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #readAsync
-- @
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readAsync"
        })

inputStreamClass_readAsync :: AttrLabelProxy "readAsync"
inputStreamClass_readAsync = AttrLabelProxy

#endif


-- | Get the value of the “@read_finish@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #readFinish
-- @
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
    FunPtr C_InputStreamClassReadFinishFieldCallback
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)
    Maybe InputStreamClassReadFinishFieldCallback
result <- FunPtr C_InputStreamClassReadFinishFieldCallback
-> (FunPtr C_InputStreamClassReadFinishFieldCallback
    -> IO InputStreamClassReadFinishFieldCallback)
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassReadFinishFieldCallback
val ((FunPtr C_InputStreamClassReadFinishFieldCallback
  -> IO InputStreamClassReadFinishFieldCallback)
 -> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> (FunPtr C_InputStreamClassReadFinishFieldCallback
    -> IO InputStreamClassReadFinishFieldCallback)
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassReadFinishFieldCallback
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassReadFinishFieldCallback
result

-- | Set the value of the “@read_finish@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #readFinish 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@read_finish@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #readFinish
-- @
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:readFinish"
        })

inputStreamClass_readFinish :: AttrLabelProxy "readFinish"
inputStreamClass_readFinish = AttrLabelProxy

#endif


-- | Get the value of the “@skip_async@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #skipAsync
-- @
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
    FunPtr C_InputStreamClassSkipAsyncFieldCallback
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)
    Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
result <- FunPtr C_InputStreamClassSkipAsyncFieldCallback
-> (FunPtr C_InputStreamClassSkipAsyncFieldCallback
    -> IO InputStreamClassSkipAsyncFieldCallback_WithClosures)
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassSkipAsyncFieldCallback
val ((FunPtr C_InputStreamClassSkipAsyncFieldCallback
  -> IO InputStreamClassSkipAsyncFieldCallback_WithClosures)
 -> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures))
-> (FunPtr C_InputStreamClassSkipAsyncFieldCallback
    -> IO InputStreamClassSkipAsyncFieldCallback_WithClosures)
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
-> IO (Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassSkipAsyncFieldCallback_WithClosures
result

-- | Set the value of the “@skip_async@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #skipAsync 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@skip_async@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #skipAsync
-- @
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skipAsync"
        })

inputStreamClass_skipAsync :: AttrLabelProxy "skipAsync"
inputStreamClass_skipAsync = AttrLabelProxy

#endif


-- | Get the value of the “@skip_finish@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #skipFinish
-- @
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
    FunPtr C_InputStreamClassReadFinishFieldCallback
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)
    Maybe InputStreamClassReadFinishFieldCallback
result <- FunPtr C_InputStreamClassReadFinishFieldCallback
-> (FunPtr C_InputStreamClassReadFinishFieldCallback
    -> IO InputStreamClassReadFinishFieldCallback)
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassReadFinishFieldCallback
val ((FunPtr C_InputStreamClassReadFinishFieldCallback
  -> IO InputStreamClassReadFinishFieldCallback)
 -> IO (Maybe InputStreamClassReadFinishFieldCallback))
-> (FunPtr C_InputStreamClassReadFinishFieldCallback
    -> IO InputStreamClassReadFinishFieldCallback)
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassReadFinishFieldCallback
-> IO (Maybe InputStreamClassReadFinishFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassReadFinishFieldCallback
result

-- | Set the value of the “@skip_finish@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #skipFinish 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@skip_finish@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #skipFinish
-- @
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:skipFinish"
        })

inputStreamClass_skipFinish :: AttrLabelProxy "skipFinish"
inputStreamClass_skipFinish = AttrLabelProxy

#endif


-- | Get the value of the “@close_async@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #closeAsync
-- @
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
    FunPtr C_InputStreamClassCloseAsyncFieldCallback
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)
    Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
result <- FunPtr C_InputStreamClassCloseAsyncFieldCallback
-> (FunPtr C_InputStreamClassCloseAsyncFieldCallback
    -> IO InputStreamClassCloseAsyncFieldCallback_WithClosures)
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassCloseAsyncFieldCallback
val ((FunPtr C_InputStreamClassCloseAsyncFieldCallback
  -> IO InputStreamClassCloseAsyncFieldCallback_WithClosures)
 -> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures))
-> (FunPtr C_InputStreamClassCloseAsyncFieldCallback
    -> IO InputStreamClassCloseAsyncFieldCallback_WithClosures)
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
-> IO (Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassCloseAsyncFieldCallback_WithClosures
result

-- | Set the value of the “@close_async@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #closeAsync 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@close_async@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #closeAsync
-- @
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.34/docs/GI-Gio-Structs-InputStreamClass.html#g:attr:closeAsync"
        })

inputStreamClass_closeAsync :: AttrLabelProxy "closeAsync"
inputStreamClass_closeAsync = AttrLabelProxy

#endif


-- | Get the value of the “@close_finish@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' inputStreamClass #closeFinish
-- @
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
    FunPtr C_InputStreamClassCloseFinishFieldCallback
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)
    Maybe InputStreamClassCloseFinishFieldCallback
result <- FunPtr C_InputStreamClassCloseFinishFieldCallback
-> (FunPtr C_InputStreamClassCloseFinishFieldCallback
    -> IO InputStreamClassCloseFinishFieldCallback)
-> IO (Maybe InputStreamClassCloseFinishFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InputStreamClassCloseFinishFieldCallback
val ((FunPtr C_InputStreamClassCloseFinishFieldCallback
  -> IO InputStreamClassCloseFinishFieldCallback)
 -> IO (Maybe InputStreamClassCloseFinishFieldCallback))
-> (FunPtr C_InputStreamClassCloseFinishFieldCallback
    -> IO InputStreamClassCloseFinishFieldCallback)
-> IO (Maybe InputStreamClassCloseFinishFieldCallback)
forall a b. (a -> b) -> a -> b
$ \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''
    Maybe InputStreamClassCloseFinishFieldCallback
-> IO (Maybe InputStreamClassCloseFinishFieldCallback)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InputStreamClassCloseFinishFieldCallback
result

-- | Set the value of the “@close_finish@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.set' inputStreamClass [ #closeFinish 'Data.GI.Base.Attributes.:=' value ]
-- @
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)

-- | Set the value of the “@close_finish@” field to `Nothing`.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.clear' #closeFinish
-- @
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.34/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