{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)

A table of functions used to handle different types of 'GI.GLib.Structs.IOChannel.IOChannel'
in a generic way.
-}

#define ENABLE_OVERLOADING \
       (!defined(__HADDOCK_VERSION__))

module GI.GLib.Structs.IOFuncs
    ( 

-- * Exported types
    IOFuncs(..)                             ,
    newZeroIOFuncs                          ,
    noIOFuncs                               ,


 -- * Properties
-- ** ioClose #attr:ioClose#
{- | /No description available in the introspection data./
-}
    clearIOFuncsIoClose                     ,
    getIOFuncsIoClose                       ,
#if ENABLE_OVERLOADING
    iOFuncs_ioClose                         ,
#endif
    setIOFuncsIoClose                       ,


-- ** ioCreateWatch #attr:ioCreateWatch#
{- | /No description available in the introspection data./
-}
    clearIOFuncsIoCreateWatch               ,
    getIOFuncsIoCreateWatch                 ,
#if ENABLE_OVERLOADING
    iOFuncs_ioCreateWatch                   ,
#endif
    setIOFuncsIoCreateWatch                 ,


-- ** ioFree #attr:ioFree#
{- | /No description available in the introspection data./
-}
    clearIOFuncsIoFree                      ,
    getIOFuncsIoFree                        ,
#if ENABLE_OVERLOADING
    iOFuncs_ioFree                          ,
#endif
    setIOFuncsIoFree                        ,


-- ** ioGetFlags #attr:ioGetFlags#
{- | /No description available in the introspection data./
-}
    clearIOFuncsIoGetFlags                  ,
    getIOFuncsIoGetFlags                    ,
#if ENABLE_OVERLOADING
    iOFuncs_ioGetFlags                      ,
#endif
    setIOFuncsIoGetFlags                    ,


-- ** ioRead #attr:ioRead#
{- | /No description available in the introspection data./
-}
    clearIOFuncsIoRead                      ,
    getIOFuncsIoRead                        ,
#if ENABLE_OVERLOADING
    iOFuncs_ioRead                          ,
#endif
    setIOFuncsIoRead                        ,


-- ** ioSeek #attr:ioSeek#
{- | /No description available in the introspection data./
-}
    clearIOFuncsIoSeek                      ,
    getIOFuncsIoSeek                        ,
#if ENABLE_OVERLOADING
    iOFuncs_ioSeek                          ,
#endif
    setIOFuncsIoSeek                        ,


-- ** ioSetFlags #attr:ioSetFlags#
{- | /No description available in the introspection data./
-}
    clearIOFuncsIoSetFlags                  ,
    getIOFuncsIoSetFlags                    ,
#if ENABLE_OVERLOADING
    iOFuncs_ioSetFlags                      ,
#endif
    setIOFuncsIoSetFlags                    ,


-- ** ioWrite #attr:ioWrite#
{- | /No description available in the introspection data./
-}
    clearIOFuncsIoWrite                     ,
    getIOFuncsIoWrite                       ,
#if ENABLE_OVERLOADING
    iOFuncs_ioWrite                         ,
#endif
    setIOFuncsIoWrite                       ,




    ) where

import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P

import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP

import qualified GI.GLib.Callbacks as GLib.Callbacks

-- | Memory-managed wrapper type.
newtype IOFuncs = IOFuncs (ManagedPtr IOFuncs)
instance WrappedPtr IOFuncs where
    wrappedPtrCalloc :: IO (Ptr IOFuncs)
wrappedPtrCalloc = Int -> IO (Ptr IOFuncs)
forall a. Int -> IO (Ptr a)
callocBytes 64
    wrappedPtrCopy :: IOFuncs -> IO IOFuncs
wrappedPtrCopy = \p :: IOFuncs
p -> IOFuncs -> (Ptr IOFuncs -> IO IOFuncs) -> IO IOFuncs
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
p (Int -> Ptr IOFuncs -> IO (Ptr IOFuncs)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 64 (Ptr IOFuncs -> IO (Ptr IOFuncs))
-> (Ptr IOFuncs -> IO IOFuncs) -> Ptr IOFuncs -> IO IOFuncs
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr IOFuncs -> IOFuncs) -> Ptr IOFuncs -> IO IOFuncs
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr IOFuncs -> IOFuncs
IOFuncs)
    wrappedPtrFree :: Maybe (FunPtr (Ptr IOFuncs -> IO ()))
wrappedPtrFree = FunPtr (Ptr IOFuncs -> IO ())
-> Maybe (FunPtr (Ptr IOFuncs -> IO ()))
forall a. a -> Maybe a
Just FunPtr (Ptr IOFuncs -> IO ())
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free

-- | Construct a `IOFuncs` struct initialized to zero.
newZeroIOFuncs :: MonadIO m => m IOFuncs
newZeroIOFuncs :: m IOFuncs
newZeroIOFuncs = IO IOFuncs -> m IOFuncs
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO IOFuncs -> m IOFuncs) -> IO IOFuncs -> m IOFuncs
forall a b. (a -> b) -> a -> b
$ IO (Ptr IOFuncs)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr IOFuncs) -> (Ptr IOFuncs -> IO IOFuncs) -> IO IOFuncs
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr IOFuncs -> IOFuncs) -> Ptr IOFuncs -> IO IOFuncs
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr IOFuncs -> IOFuncs
IOFuncs

instance tag ~ 'AttrSet => Constructible IOFuncs tag where
    new :: (ManagedPtr IOFuncs -> IOFuncs)
-> [AttrOp IOFuncs tag] -> m IOFuncs
new _ attrs :: [AttrOp IOFuncs tag]
attrs = do
        IOFuncs
o <- m IOFuncs
forall (m :: * -> *). MonadIO m => m IOFuncs
newZeroIOFuncs
        IOFuncs -> [AttrOp IOFuncs 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set IOFuncs
o [AttrOp IOFuncs tag]
[AttrOp IOFuncs 'AttrSet]
attrs
        IOFuncs -> m IOFuncs
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncs
o


-- | A convenience alias for `Nothing` :: `Maybe` `IOFuncs`.
noIOFuncs :: Maybe IOFuncs
noIOFuncs :: Maybe IOFuncs
noIOFuncs = Maybe IOFuncs
forall a. Maybe a
Nothing

{- |
Get the value of the “@io_read@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' iOFuncs #ioRead
@
-}
getIOFuncsIoRead :: MonadIO m => IOFuncs -> m (Maybe GLib.Callbacks.IOFuncsIoReadFieldCallback)
getIOFuncsIoRead :: IOFuncs -> m (Maybe IOFuncsIoReadFieldCallback)
getIOFuncsIoRead s :: IOFuncs
s = IO (Maybe IOFuncsIoReadFieldCallback)
-> m (Maybe IOFuncsIoReadFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IOFuncsIoReadFieldCallback)
 -> m (Maybe IOFuncsIoReadFieldCallback))
-> IO (Maybe IOFuncsIoReadFieldCallback)
-> m (Maybe IOFuncsIoReadFieldCallback)
forall a b. (a -> b) -> a -> b
$ IOFuncs
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoReadFieldCallback))
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO (Maybe IOFuncsIoReadFieldCallback))
 -> IO (Maybe IOFuncsIoReadFieldCallback))
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoReadFieldCallback))
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    FunPtr C_IOFuncsIoReadFieldCallback
val <- Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
-> IO (FunPtr C_IOFuncsIoReadFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO (FunPtr GLib.Callbacks.C_IOFuncsIoReadFieldCallback)
    Maybe IOFuncsIoReadFieldCallback
result <- FunPtr C_IOFuncsIoReadFieldCallback
-> (FunPtr C_IOFuncsIoReadFieldCallback
    -> IO IOFuncsIoReadFieldCallback)
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_IOFuncsIoReadFieldCallback
val ((FunPtr C_IOFuncsIoReadFieldCallback
  -> IO IOFuncsIoReadFieldCallback)
 -> IO (Maybe IOFuncsIoReadFieldCallback))
-> (FunPtr C_IOFuncsIoReadFieldCallback
    -> IO IOFuncsIoReadFieldCallback)
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_IOFuncsIoReadFieldCallback
val' -> do
        let val'' :: IOFuncsIoReadFieldCallback
val'' = FunPtr C_IOFuncsIoReadFieldCallback -> IOFuncsIoReadFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_IOFuncsIoReadFieldCallback
-> IOChannel -> Text -> Word64 -> Word64 -> m IOStatus
GLib.Callbacks.dynamic_IOFuncsIoReadFieldCallback FunPtr C_IOFuncsIoReadFieldCallback
val'
        IOFuncsIoReadFieldCallback -> IO IOFuncsIoReadFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncsIoReadFieldCallback
val''
    Maybe IOFuncsIoReadFieldCallback
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IOFuncsIoReadFieldCallback
result

{- |
Set the value of the “@io_read@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' iOFuncs [ #ioRead 'Data.GI.Base.Attributes.:=' value ]
@
-}
setIOFuncsIoRead :: MonadIO m => IOFuncs -> FunPtr GLib.Callbacks.C_IOFuncsIoReadFieldCallback -> m ()
setIOFuncsIoRead :: IOFuncs -> FunPtr C_IOFuncsIoReadFieldCallback -> m ()
setIOFuncsIoRead s :: IOFuncs
s val :: FunPtr C_IOFuncsIoReadFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
-> FunPtr C_IOFuncsIoReadFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (FunPtr C_IOFuncsIoReadFieldCallback
val :: FunPtr GLib.Callbacks.C_IOFuncsIoReadFieldCallback)

{- |
Set the value of the “@io_read@” 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' #ioRead
@
-}
clearIOFuncsIoRead :: MonadIO m => IOFuncs -> m ()
clearIOFuncsIoRead :: IOFuncs -> m ()
clearIOFuncsIoRead s :: IOFuncs
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
-> FunPtr C_IOFuncsIoReadFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (FunPtr C_IOFuncsIoReadFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_IOFuncsIoReadFieldCallback)

#if ENABLE_OVERLOADING
data IOFuncsIoReadFieldInfo
instance AttrInfo IOFuncsIoReadFieldInfo where
    type AttrAllowedOps IOFuncsIoReadFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint IOFuncsIoReadFieldInfo = (~) (FunPtr GLib.Callbacks.C_IOFuncsIoReadFieldCallback)
    type AttrBaseTypeConstraint IOFuncsIoReadFieldInfo = (~) IOFuncs
    type AttrGetType IOFuncsIoReadFieldInfo = Maybe GLib.Callbacks.IOFuncsIoReadFieldCallback
    type AttrLabel IOFuncsIoReadFieldInfo = "io_read"
    type AttrOrigin IOFuncsIoReadFieldInfo = IOFuncs
    attrGet _ = getIOFuncsIoRead
    attrSet _ = setIOFuncsIoRead
    attrConstruct = undefined
    attrClear _ = clearIOFuncsIoRead

iOFuncs_ioRead :: AttrLabelProxy "ioRead"
iOFuncs_ioRead = AttrLabelProxy

#endif


{- |
Get the value of the “@io_write@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' iOFuncs #ioWrite
@
-}
getIOFuncsIoWrite :: MonadIO m => IOFuncs -> m (Maybe GLib.Callbacks.IOFuncsIoWriteFieldCallback)
getIOFuncsIoWrite :: IOFuncs -> m (Maybe IOFuncsIoReadFieldCallback)
getIOFuncsIoWrite s :: IOFuncs
s = IO (Maybe IOFuncsIoReadFieldCallback)
-> m (Maybe IOFuncsIoReadFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IOFuncsIoReadFieldCallback)
 -> m (Maybe IOFuncsIoReadFieldCallback))
-> IO (Maybe IOFuncsIoReadFieldCallback)
-> m (Maybe IOFuncsIoReadFieldCallback)
forall a b. (a -> b) -> a -> b
$ IOFuncs
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoReadFieldCallback))
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO (Maybe IOFuncsIoReadFieldCallback))
 -> IO (Maybe IOFuncsIoReadFieldCallback))
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoReadFieldCallback))
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    FunPtr C_IOFuncsIoReadFieldCallback
val <- Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
-> IO (FunPtr C_IOFuncsIoReadFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO (FunPtr GLib.Callbacks.C_IOFuncsIoWriteFieldCallback)
    Maybe IOFuncsIoReadFieldCallback
result <- FunPtr C_IOFuncsIoReadFieldCallback
-> (FunPtr C_IOFuncsIoReadFieldCallback
    -> IO IOFuncsIoReadFieldCallback)
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_IOFuncsIoReadFieldCallback
val ((FunPtr C_IOFuncsIoReadFieldCallback
  -> IO IOFuncsIoReadFieldCallback)
 -> IO (Maybe IOFuncsIoReadFieldCallback))
-> (FunPtr C_IOFuncsIoReadFieldCallback
    -> IO IOFuncsIoReadFieldCallback)
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_IOFuncsIoReadFieldCallback
val' -> do
        let val'' :: IOFuncsIoReadFieldCallback
val'' = FunPtr C_IOFuncsIoReadFieldCallback -> IOFuncsIoReadFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_IOFuncsIoReadFieldCallback
-> IOChannel -> Text -> Word64 -> Word64 -> m IOStatus
GLib.Callbacks.dynamic_IOFuncsIoWriteFieldCallback FunPtr C_IOFuncsIoReadFieldCallback
val'
        IOFuncsIoReadFieldCallback -> IO IOFuncsIoReadFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncsIoReadFieldCallback
val''
    Maybe IOFuncsIoReadFieldCallback
-> IO (Maybe IOFuncsIoReadFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IOFuncsIoReadFieldCallback
result

{- |
Set the value of the “@io_write@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' iOFuncs [ #ioWrite 'Data.GI.Base.Attributes.:=' value ]
@
-}
setIOFuncsIoWrite :: MonadIO m => IOFuncs -> FunPtr GLib.Callbacks.C_IOFuncsIoWriteFieldCallback -> m ()
setIOFuncsIoWrite :: IOFuncs -> FunPtr C_IOFuncsIoReadFieldCallback -> m ()
setIOFuncsIoWrite s :: IOFuncs
s val :: FunPtr C_IOFuncsIoReadFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
-> FunPtr C_IOFuncsIoReadFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (FunPtr C_IOFuncsIoReadFieldCallback
val :: FunPtr GLib.Callbacks.C_IOFuncsIoWriteFieldCallback)

{- |
Set the value of the “@io_write@” 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' #ioWrite
@
-}
clearIOFuncsIoWrite :: MonadIO m => IOFuncs -> m ()
clearIOFuncsIoWrite :: IOFuncs -> m ()
clearIOFuncsIoWrite s :: IOFuncs
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
-> FunPtr C_IOFuncsIoReadFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoReadFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (FunPtr C_IOFuncsIoReadFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_IOFuncsIoWriteFieldCallback)

#if ENABLE_OVERLOADING
data IOFuncsIoWriteFieldInfo
instance AttrInfo IOFuncsIoWriteFieldInfo where
    type AttrAllowedOps IOFuncsIoWriteFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint IOFuncsIoWriteFieldInfo = (~) (FunPtr GLib.Callbacks.C_IOFuncsIoWriteFieldCallback)
    type AttrBaseTypeConstraint IOFuncsIoWriteFieldInfo = (~) IOFuncs
    type AttrGetType IOFuncsIoWriteFieldInfo = Maybe GLib.Callbacks.IOFuncsIoWriteFieldCallback
    type AttrLabel IOFuncsIoWriteFieldInfo = "io_write"
    type AttrOrigin IOFuncsIoWriteFieldInfo = IOFuncs
    attrGet _ = getIOFuncsIoWrite
    attrSet _ = setIOFuncsIoWrite
    attrConstruct = undefined
    attrClear _ = clearIOFuncsIoWrite

iOFuncs_ioWrite :: AttrLabelProxy "ioWrite"
iOFuncs_ioWrite = AttrLabelProxy

#endif


{- |
Get the value of the “@io_seek@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' iOFuncs #ioSeek
@
-}
getIOFuncsIoSeek :: MonadIO m => IOFuncs -> m (Maybe GLib.Callbacks.IOFuncsIoSeekFieldCallback)
getIOFuncsIoSeek :: IOFuncs -> m (Maybe IOFuncsIoSeekFieldCallback)
getIOFuncsIoSeek s :: IOFuncs
s = IO (Maybe IOFuncsIoSeekFieldCallback)
-> m (Maybe IOFuncsIoSeekFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IOFuncsIoSeekFieldCallback)
 -> m (Maybe IOFuncsIoSeekFieldCallback))
-> IO (Maybe IOFuncsIoSeekFieldCallback)
-> m (Maybe IOFuncsIoSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ IOFuncs
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoSeekFieldCallback))
-> IO (Maybe IOFuncsIoSeekFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO (Maybe IOFuncsIoSeekFieldCallback))
 -> IO (Maybe IOFuncsIoSeekFieldCallback))
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoSeekFieldCallback))
-> IO (Maybe IOFuncsIoSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    FunPtr C_IOFuncsIoSeekFieldCallback
val <- Ptr (FunPtr C_IOFuncsIoSeekFieldCallback)
-> IO (FunPtr C_IOFuncsIoSeekFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO (FunPtr GLib.Callbacks.C_IOFuncsIoSeekFieldCallback)
    Maybe IOFuncsIoSeekFieldCallback
result <- FunPtr C_IOFuncsIoSeekFieldCallback
-> (FunPtr C_IOFuncsIoSeekFieldCallback
    -> IO IOFuncsIoSeekFieldCallback)
-> IO (Maybe IOFuncsIoSeekFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_IOFuncsIoSeekFieldCallback
val ((FunPtr C_IOFuncsIoSeekFieldCallback
  -> IO IOFuncsIoSeekFieldCallback)
 -> IO (Maybe IOFuncsIoSeekFieldCallback))
-> (FunPtr C_IOFuncsIoSeekFieldCallback
    -> IO IOFuncsIoSeekFieldCallback)
-> IO (Maybe IOFuncsIoSeekFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_IOFuncsIoSeekFieldCallback
val' -> do
        let val'' :: IOFuncsIoSeekFieldCallback
val'' = FunPtr C_IOFuncsIoSeekFieldCallback -> IOFuncsIoSeekFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_IOFuncsIoSeekFieldCallback
-> IOChannel -> Int64 -> SeekType -> m IOStatus
GLib.Callbacks.dynamic_IOFuncsIoSeekFieldCallback FunPtr C_IOFuncsIoSeekFieldCallback
val'
        IOFuncsIoSeekFieldCallback -> IO IOFuncsIoSeekFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncsIoSeekFieldCallback
val''
    Maybe IOFuncsIoSeekFieldCallback
-> IO (Maybe IOFuncsIoSeekFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IOFuncsIoSeekFieldCallback
result

{- |
Set the value of the “@io_seek@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' iOFuncs [ #ioSeek 'Data.GI.Base.Attributes.:=' value ]
@
-}
setIOFuncsIoSeek :: MonadIO m => IOFuncs -> FunPtr GLib.Callbacks.C_IOFuncsIoSeekFieldCallback -> m ()
setIOFuncsIoSeek :: IOFuncs -> FunPtr C_IOFuncsIoSeekFieldCallback -> m ()
setIOFuncsIoSeek s :: IOFuncs
s val :: FunPtr C_IOFuncsIoSeekFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoSeekFieldCallback)
-> FunPtr C_IOFuncsIoSeekFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (FunPtr C_IOFuncsIoSeekFieldCallback
val :: FunPtr GLib.Callbacks.C_IOFuncsIoSeekFieldCallback)

{- |
Set the value of the “@io_seek@” 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' #ioSeek
@
-}
clearIOFuncsIoSeek :: MonadIO m => IOFuncs -> m ()
clearIOFuncsIoSeek :: IOFuncs -> m ()
clearIOFuncsIoSeek s :: IOFuncs
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoSeekFieldCallback)
-> FunPtr C_IOFuncsIoSeekFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoSeekFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (FunPtr C_IOFuncsIoSeekFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_IOFuncsIoSeekFieldCallback)

#if ENABLE_OVERLOADING
data IOFuncsIoSeekFieldInfo
instance AttrInfo IOFuncsIoSeekFieldInfo where
    type AttrAllowedOps IOFuncsIoSeekFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint IOFuncsIoSeekFieldInfo = (~) (FunPtr GLib.Callbacks.C_IOFuncsIoSeekFieldCallback)
    type AttrBaseTypeConstraint IOFuncsIoSeekFieldInfo = (~) IOFuncs
    type AttrGetType IOFuncsIoSeekFieldInfo = Maybe GLib.Callbacks.IOFuncsIoSeekFieldCallback
    type AttrLabel IOFuncsIoSeekFieldInfo = "io_seek"
    type AttrOrigin IOFuncsIoSeekFieldInfo = IOFuncs
    attrGet _ = getIOFuncsIoSeek
    attrSet _ = setIOFuncsIoSeek
    attrConstruct = undefined
    attrClear _ = clearIOFuncsIoSeek

iOFuncs_ioSeek :: AttrLabelProxy "ioSeek"
iOFuncs_ioSeek = AttrLabelProxy

#endif


{- |
Get the value of the “@io_close@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' iOFuncs #ioClose
@
-}
getIOFuncsIoClose :: MonadIO m => IOFuncs -> m (Maybe GLib.Callbacks.IOFuncsIoCloseFieldCallback)
getIOFuncsIoClose :: IOFuncs -> m (Maybe IOFuncsIoCloseFieldCallback)
getIOFuncsIoClose s :: IOFuncs
s = IO (Maybe IOFuncsIoCloseFieldCallback)
-> m (Maybe IOFuncsIoCloseFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IOFuncsIoCloseFieldCallback)
 -> m (Maybe IOFuncsIoCloseFieldCallback))
-> IO (Maybe IOFuncsIoCloseFieldCallback)
-> m (Maybe IOFuncsIoCloseFieldCallback)
forall a b. (a -> b) -> a -> b
$ IOFuncs
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoCloseFieldCallback))
-> IO (Maybe IOFuncsIoCloseFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO (Maybe IOFuncsIoCloseFieldCallback))
 -> IO (Maybe IOFuncsIoCloseFieldCallback))
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoCloseFieldCallback))
-> IO (Maybe IOFuncsIoCloseFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    FunPtr C_IOFuncsIoCloseFieldCallback
val <- Ptr (FunPtr C_IOFuncsIoCloseFieldCallback)
-> IO (FunPtr C_IOFuncsIoCloseFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoCloseFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO (FunPtr GLib.Callbacks.C_IOFuncsIoCloseFieldCallback)
    Maybe IOFuncsIoCloseFieldCallback
result <- FunPtr C_IOFuncsIoCloseFieldCallback
-> (FunPtr C_IOFuncsIoCloseFieldCallback
    -> IO IOFuncsIoCloseFieldCallback)
-> IO (Maybe IOFuncsIoCloseFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_IOFuncsIoCloseFieldCallback
val ((FunPtr C_IOFuncsIoCloseFieldCallback
  -> IO IOFuncsIoCloseFieldCallback)
 -> IO (Maybe IOFuncsIoCloseFieldCallback))
-> (FunPtr C_IOFuncsIoCloseFieldCallback
    -> IO IOFuncsIoCloseFieldCallback)
-> IO (Maybe IOFuncsIoCloseFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_IOFuncsIoCloseFieldCallback
val' -> do
        let val'' :: IOFuncsIoCloseFieldCallback
val'' = FunPtr C_IOFuncsIoCloseFieldCallback -> IOFuncsIoCloseFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_IOFuncsIoCloseFieldCallback -> IOChannel -> m IOStatus
GLib.Callbacks.dynamic_IOFuncsIoCloseFieldCallback FunPtr C_IOFuncsIoCloseFieldCallback
val'
        IOFuncsIoCloseFieldCallback -> IO IOFuncsIoCloseFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncsIoCloseFieldCallback
val''
    Maybe IOFuncsIoCloseFieldCallback
-> IO (Maybe IOFuncsIoCloseFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IOFuncsIoCloseFieldCallback
result

{- |
Set the value of the “@io_close@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' iOFuncs [ #ioClose 'Data.GI.Base.Attributes.:=' value ]
@
-}
setIOFuncsIoClose :: MonadIO m => IOFuncs -> FunPtr GLib.Callbacks.C_IOFuncsIoCloseFieldCallback -> m ()
setIOFuncsIoClose :: IOFuncs -> FunPtr C_IOFuncsIoCloseFieldCallback -> m ()
setIOFuncsIoClose s :: IOFuncs
s val :: FunPtr C_IOFuncsIoCloseFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoCloseFieldCallback)
-> FunPtr C_IOFuncsIoCloseFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoCloseFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (FunPtr C_IOFuncsIoCloseFieldCallback
val :: FunPtr GLib.Callbacks.C_IOFuncsIoCloseFieldCallback)

{- |
Set the value of the “@io_close@” 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' #ioClose
@
-}
clearIOFuncsIoClose :: MonadIO m => IOFuncs -> m ()
clearIOFuncsIoClose :: IOFuncs -> m ()
clearIOFuncsIoClose s :: IOFuncs
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoCloseFieldCallback)
-> FunPtr C_IOFuncsIoCloseFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoCloseFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (FunPtr C_IOFuncsIoCloseFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_IOFuncsIoCloseFieldCallback)

#if ENABLE_OVERLOADING
data IOFuncsIoCloseFieldInfo
instance AttrInfo IOFuncsIoCloseFieldInfo where
    type AttrAllowedOps IOFuncsIoCloseFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint IOFuncsIoCloseFieldInfo = (~) (FunPtr GLib.Callbacks.C_IOFuncsIoCloseFieldCallback)
    type AttrBaseTypeConstraint IOFuncsIoCloseFieldInfo = (~) IOFuncs
    type AttrGetType IOFuncsIoCloseFieldInfo = Maybe GLib.Callbacks.IOFuncsIoCloseFieldCallback
    type AttrLabel IOFuncsIoCloseFieldInfo = "io_close"
    type AttrOrigin IOFuncsIoCloseFieldInfo = IOFuncs
    attrGet _ = getIOFuncsIoClose
    attrSet _ = setIOFuncsIoClose
    attrConstruct = undefined
    attrClear _ = clearIOFuncsIoClose

iOFuncs_ioClose :: AttrLabelProxy "ioClose"
iOFuncs_ioClose = AttrLabelProxy

#endif


{- |
Get the value of the “@io_create_watch@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' iOFuncs #ioCreateWatch
@
-}
getIOFuncsIoCreateWatch :: MonadIO m => IOFuncs -> m (Maybe GLib.Callbacks.IOFuncsIoCreateWatchFieldCallback)
getIOFuncsIoCreateWatch :: IOFuncs -> m (Maybe IOFuncsIoCreateWatchFieldCallback)
getIOFuncsIoCreateWatch s :: IOFuncs
s = IO (Maybe IOFuncsIoCreateWatchFieldCallback)
-> m (Maybe IOFuncsIoCreateWatchFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IOFuncsIoCreateWatchFieldCallback)
 -> m (Maybe IOFuncsIoCreateWatchFieldCallback))
-> IO (Maybe IOFuncsIoCreateWatchFieldCallback)
-> m (Maybe IOFuncsIoCreateWatchFieldCallback)
forall a b. (a -> b) -> a -> b
$ IOFuncs
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoCreateWatchFieldCallback))
-> IO (Maybe IOFuncsIoCreateWatchFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO (Maybe IOFuncsIoCreateWatchFieldCallback))
 -> IO (Maybe IOFuncsIoCreateWatchFieldCallback))
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoCreateWatchFieldCallback))
-> IO (Maybe IOFuncsIoCreateWatchFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    FunPtr C_IOFuncsIoCreateWatchFieldCallback
val <- Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)
-> IO (FunPtr C_IOFuncsIoCreateWatchFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr IOFuncs
ptr Ptr IOFuncs
-> Int -> Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) :: IO (FunPtr GLib.Callbacks.C_IOFuncsIoCreateWatchFieldCallback)
    Maybe IOFuncsIoCreateWatchFieldCallback
result <- FunPtr C_IOFuncsIoCreateWatchFieldCallback
-> (FunPtr C_IOFuncsIoCreateWatchFieldCallback
    -> IO IOFuncsIoCreateWatchFieldCallback)
-> IO (Maybe IOFuncsIoCreateWatchFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_IOFuncsIoCreateWatchFieldCallback
val ((FunPtr C_IOFuncsIoCreateWatchFieldCallback
  -> IO IOFuncsIoCreateWatchFieldCallback)
 -> IO (Maybe IOFuncsIoCreateWatchFieldCallback))
-> (FunPtr C_IOFuncsIoCreateWatchFieldCallback
    -> IO IOFuncsIoCreateWatchFieldCallback)
-> IO (Maybe IOFuncsIoCreateWatchFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_IOFuncsIoCreateWatchFieldCallback
val' -> do
        let val'' :: IOFuncsIoCreateWatchFieldCallback
val'' = FunPtr C_IOFuncsIoCreateWatchFieldCallback
-> IOFuncsIoCreateWatchFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_IOFuncsIoCreateWatchFieldCallback
-> IOChannel -> [IOCondition] -> m Source
GLib.Callbacks.dynamic_IOFuncsIoCreateWatchFieldCallback FunPtr C_IOFuncsIoCreateWatchFieldCallback
val'
        IOFuncsIoCreateWatchFieldCallback
-> IO IOFuncsIoCreateWatchFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncsIoCreateWatchFieldCallback
val''
    Maybe IOFuncsIoCreateWatchFieldCallback
-> IO (Maybe IOFuncsIoCreateWatchFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IOFuncsIoCreateWatchFieldCallback
result

{- |
Set the value of the “@io_create_watch@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' iOFuncs [ #ioCreateWatch 'Data.GI.Base.Attributes.:=' value ]
@
-}
setIOFuncsIoCreateWatch :: MonadIO m => IOFuncs -> FunPtr GLib.Callbacks.C_IOFuncsIoCreateWatchFieldCallback -> m ()
setIOFuncsIoCreateWatch :: IOFuncs -> FunPtr C_IOFuncsIoCreateWatchFieldCallback -> m ()
setIOFuncsIoCreateWatch s :: IOFuncs
s val :: FunPtr C_IOFuncsIoCreateWatchFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)
-> FunPtr C_IOFuncsIoCreateWatchFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs
-> Int -> Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (FunPtr C_IOFuncsIoCreateWatchFieldCallback
val :: FunPtr GLib.Callbacks.C_IOFuncsIoCreateWatchFieldCallback)

{- |
Set the value of the “@io_create_watch@” 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' #ioCreateWatch
@
-}
clearIOFuncsIoCreateWatch :: MonadIO m => IOFuncs -> m ()
clearIOFuncsIoCreateWatch :: IOFuncs -> m ()
clearIOFuncsIoCreateWatch s :: IOFuncs
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)
-> FunPtr C_IOFuncsIoCreateWatchFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs
-> Int -> Ptr (FunPtr C_IOFuncsIoCreateWatchFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (FunPtr C_IOFuncsIoCreateWatchFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_IOFuncsIoCreateWatchFieldCallback)

#if ENABLE_OVERLOADING
data IOFuncsIoCreateWatchFieldInfo
instance AttrInfo IOFuncsIoCreateWatchFieldInfo where
    type AttrAllowedOps IOFuncsIoCreateWatchFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint IOFuncsIoCreateWatchFieldInfo = (~) (FunPtr GLib.Callbacks.C_IOFuncsIoCreateWatchFieldCallback)
    type AttrBaseTypeConstraint IOFuncsIoCreateWatchFieldInfo = (~) IOFuncs
    type AttrGetType IOFuncsIoCreateWatchFieldInfo = Maybe GLib.Callbacks.IOFuncsIoCreateWatchFieldCallback
    type AttrLabel IOFuncsIoCreateWatchFieldInfo = "io_create_watch"
    type AttrOrigin IOFuncsIoCreateWatchFieldInfo = IOFuncs
    attrGet _ = getIOFuncsIoCreateWatch
    attrSet _ = setIOFuncsIoCreateWatch
    attrConstruct = undefined
    attrClear _ = clearIOFuncsIoCreateWatch

iOFuncs_ioCreateWatch :: AttrLabelProxy "ioCreateWatch"
iOFuncs_ioCreateWatch = AttrLabelProxy

#endif


{- |
Get the value of the “@io_free@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' iOFuncs #ioFree
@
-}
getIOFuncsIoFree :: MonadIO m => IOFuncs -> m (Maybe GLib.Callbacks.IOFuncsIoFreeFieldCallback)
getIOFuncsIoFree :: IOFuncs -> m (Maybe IOFuncsIoFreeFieldCallback)
getIOFuncsIoFree s :: IOFuncs
s = IO (Maybe IOFuncsIoFreeFieldCallback)
-> m (Maybe IOFuncsIoFreeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IOFuncsIoFreeFieldCallback)
 -> m (Maybe IOFuncsIoFreeFieldCallback))
-> IO (Maybe IOFuncsIoFreeFieldCallback)
-> m (Maybe IOFuncsIoFreeFieldCallback)
forall a b. (a -> b) -> a -> b
$ IOFuncs
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoFreeFieldCallback))
-> IO (Maybe IOFuncsIoFreeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO (Maybe IOFuncsIoFreeFieldCallback))
 -> IO (Maybe IOFuncsIoFreeFieldCallback))
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoFreeFieldCallback))
-> IO (Maybe IOFuncsIoFreeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    FunPtr C_IOFuncsIoFreeFieldCallback
val <- Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)
-> IO (FunPtr C_IOFuncsIoFreeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) :: IO (FunPtr GLib.Callbacks.C_IOFuncsIoFreeFieldCallback)
    Maybe IOFuncsIoFreeFieldCallback
result <- FunPtr C_IOFuncsIoFreeFieldCallback
-> (FunPtr C_IOFuncsIoFreeFieldCallback
    -> IO IOFuncsIoFreeFieldCallback)
-> IO (Maybe IOFuncsIoFreeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_IOFuncsIoFreeFieldCallback
val ((FunPtr C_IOFuncsIoFreeFieldCallback
  -> IO IOFuncsIoFreeFieldCallback)
 -> IO (Maybe IOFuncsIoFreeFieldCallback))
-> (FunPtr C_IOFuncsIoFreeFieldCallback
    -> IO IOFuncsIoFreeFieldCallback)
-> IO (Maybe IOFuncsIoFreeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_IOFuncsIoFreeFieldCallback
val' -> do
        let val'' :: IOFuncsIoFreeFieldCallback
val'' = FunPtr C_IOFuncsIoFreeFieldCallback -> IOFuncsIoFreeFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_IOFuncsIoFreeFieldCallback -> IOChannel -> m ()
GLib.Callbacks.dynamic_IOFuncsIoFreeFieldCallback FunPtr C_IOFuncsIoFreeFieldCallback
val'
        IOFuncsIoFreeFieldCallback -> IO IOFuncsIoFreeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncsIoFreeFieldCallback
val''
    Maybe IOFuncsIoFreeFieldCallback
-> IO (Maybe IOFuncsIoFreeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IOFuncsIoFreeFieldCallback
result

{- |
Set the value of the “@io_free@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' iOFuncs [ #ioFree 'Data.GI.Base.Attributes.:=' value ]
@
-}
setIOFuncsIoFree :: MonadIO m => IOFuncs -> FunPtr GLib.Callbacks.C_IOFuncsIoFreeFieldCallback -> m ()
setIOFuncsIoFree :: IOFuncs -> FunPtr C_IOFuncsIoFreeFieldCallback -> m ()
setIOFuncsIoFree s :: IOFuncs
s val :: FunPtr C_IOFuncsIoFreeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)
-> FunPtr C_IOFuncsIoFreeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (FunPtr C_IOFuncsIoFreeFieldCallback
val :: FunPtr GLib.Callbacks.C_IOFuncsIoFreeFieldCallback)

{- |
Set the value of the “@io_free@” 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' #ioFree
@
-}
clearIOFuncsIoFree :: MonadIO m => IOFuncs -> m ()
clearIOFuncsIoFree :: IOFuncs -> m ()
clearIOFuncsIoFree s :: IOFuncs
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)
-> FunPtr C_IOFuncsIoFreeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoFreeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (FunPtr C_IOFuncsIoFreeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_IOFuncsIoFreeFieldCallback)

#if ENABLE_OVERLOADING
data IOFuncsIoFreeFieldInfo
instance AttrInfo IOFuncsIoFreeFieldInfo where
    type AttrAllowedOps IOFuncsIoFreeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint IOFuncsIoFreeFieldInfo = (~) (FunPtr GLib.Callbacks.C_IOFuncsIoFreeFieldCallback)
    type AttrBaseTypeConstraint IOFuncsIoFreeFieldInfo = (~) IOFuncs
    type AttrGetType IOFuncsIoFreeFieldInfo = Maybe GLib.Callbacks.IOFuncsIoFreeFieldCallback
    type AttrLabel IOFuncsIoFreeFieldInfo = "io_free"
    type AttrOrigin IOFuncsIoFreeFieldInfo = IOFuncs
    attrGet _ = getIOFuncsIoFree
    attrSet _ = setIOFuncsIoFree
    attrConstruct = undefined
    attrClear _ = clearIOFuncsIoFree

iOFuncs_ioFree :: AttrLabelProxy "ioFree"
iOFuncs_ioFree = AttrLabelProxy

#endif


{- |
Get the value of the “@io_set_flags@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' iOFuncs #ioSetFlags
@
-}
getIOFuncsIoSetFlags :: MonadIO m => IOFuncs -> m (Maybe GLib.Callbacks.IOFuncsIoSetFlagsFieldCallback)
getIOFuncsIoSetFlags :: IOFuncs -> m (Maybe IOFuncsIoSetFlagsFieldCallback)
getIOFuncsIoSetFlags s :: IOFuncs
s = IO (Maybe IOFuncsIoSetFlagsFieldCallback)
-> m (Maybe IOFuncsIoSetFlagsFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IOFuncsIoSetFlagsFieldCallback)
 -> m (Maybe IOFuncsIoSetFlagsFieldCallback))
-> IO (Maybe IOFuncsIoSetFlagsFieldCallback)
-> m (Maybe IOFuncsIoSetFlagsFieldCallback)
forall a b. (a -> b) -> a -> b
$ IOFuncs
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoSetFlagsFieldCallback))
-> IO (Maybe IOFuncsIoSetFlagsFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO (Maybe IOFuncsIoSetFlagsFieldCallback))
 -> IO (Maybe IOFuncsIoSetFlagsFieldCallback))
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoSetFlagsFieldCallback))
-> IO (Maybe IOFuncsIoSetFlagsFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    FunPtr C_IOFuncsIoSetFlagsFieldCallback
val <- Ptr (FunPtr C_IOFuncsIoSetFlagsFieldCallback)
-> IO (FunPtr C_IOFuncsIoSetFlagsFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoSetFlagsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 48) :: IO (FunPtr GLib.Callbacks.C_IOFuncsIoSetFlagsFieldCallback)
    Maybe IOFuncsIoSetFlagsFieldCallback
result <- FunPtr C_IOFuncsIoSetFlagsFieldCallback
-> (FunPtr C_IOFuncsIoSetFlagsFieldCallback
    -> IO IOFuncsIoSetFlagsFieldCallback)
-> IO (Maybe IOFuncsIoSetFlagsFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_IOFuncsIoSetFlagsFieldCallback
val ((FunPtr C_IOFuncsIoSetFlagsFieldCallback
  -> IO IOFuncsIoSetFlagsFieldCallback)
 -> IO (Maybe IOFuncsIoSetFlagsFieldCallback))
-> (FunPtr C_IOFuncsIoSetFlagsFieldCallback
    -> IO IOFuncsIoSetFlagsFieldCallback)
-> IO (Maybe IOFuncsIoSetFlagsFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_IOFuncsIoSetFlagsFieldCallback
val' -> do
        let val'' :: IOFuncsIoSetFlagsFieldCallback
val'' = FunPtr C_IOFuncsIoSetFlagsFieldCallback
-> IOFuncsIoSetFlagsFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_IOFuncsIoSetFlagsFieldCallback
-> IOChannel -> [IOFlags] -> m IOStatus
GLib.Callbacks.dynamic_IOFuncsIoSetFlagsFieldCallback FunPtr C_IOFuncsIoSetFlagsFieldCallback
val'
        IOFuncsIoSetFlagsFieldCallback -> IO IOFuncsIoSetFlagsFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncsIoSetFlagsFieldCallback
val''
    Maybe IOFuncsIoSetFlagsFieldCallback
-> IO (Maybe IOFuncsIoSetFlagsFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IOFuncsIoSetFlagsFieldCallback
result

{- |
Set the value of the “@io_set_flags@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' iOFuncs [ #ioSetFlags 'Data.GI.Base.Attributes.:=' value ]
@
-}
setIOFuncsIoSetFlags :: MonadIO m => IOFuncs -> FunPtr GLib.Callbacks.C_IOFuncsIoSetFlagsFieldCallback -> m ()
setIOFuncsIoSetFlags :: IOFuncs -> FunPtr C_IOFuncsIoSetFlagsFieldCallback -> m ()
setIOFuncsIoSetFlags s :: IOFuncs
s val :: FunPtr C_IOFuncsIoSetFlagsFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoSetFlagsFieldCallback)
-> FunPtr C_IOFuncsIoSetFlagsFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoSetFlagsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 48) (FunPtr C_IOFuncsIoSetFlagsFieldCallback
val :: FunPtr GLib.Callbacks.C_IOFuncsIoSetFlagsFieldCallback)

{- |
Set the value of the “@io_set_flags@” 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' #ioSetFlags
@
-}
clearIOFuncsIoSetFlags :: MonadIO m => IOFuncs -> m ()
clearIOFuncsIoSetFlags :: IOFuncs -> m ()
clearIOFuncsIoSetFlags s :: IOFuncs
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoSetFlagsFieldCallback)
-> FunPtr C_IOFuncsIoSetFlagsFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoSetFlagsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 48) (FunPtr C_IOFuncsIoSetFlagsFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_IOFuncsIoSetFlagsFieldCallback)

#if ENABLE_OVERLOADING
data IOFuncsIoSetFlagsFieldInfo
instance AttrInfo IOFuncsIoSetFlagsFieldInfo where
    type AttrAllowedOps IOFuncsIoSetFlagsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint IOFuncsIoSetFlagsFieldInfo = (~) (FunPtr GLib.Callbacks.C_IOFuncsIoSetFlagsFieldCallback)
    type AttrBaseTypeConstraint IOFuncsIoSetFlagsFieldInfo = (~) IOFuncs
    type AttrGetType IOFuncsIoSetFlagsFieldInfo = Maybe GLib.Callbacks.IOFuncsIoSetFlagsFieldCallback
    type AttrLabel IOFuncsIoSetFlagsFieldInfo = "io_set_flags"
    type AttrOrigin IOFuncsIoSetFlagsFieldInfo = IOFuncs
    attrGet _ = getIOFuncsIoSetFlags
    attrSet _ = setIOFuncsIoSetFlags
    attrConstruct = undefined
    attrClear _ = clearIOFuncsIoSetFlags

iOFuncs_ioSetFlags :: AttrLabelProxy "ioSetFlags"
iOFuncs_ioSetFlags = AttrLabelProxy

#endif


{- |
Get the value of the “@io_get_flags@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.get' iOFuncs #ioGetFlags
@
-}
getIOFuncsIoGetFlags :: MonadIO m => IOFuncs -> m (Maybe GLib.Callbacks.IOFuncsIoGetFlagsFieldCallback)
getIOFuncsIoGetFlags :: IOFuncs -> m (Maybe IOFuncsIoGetFlagsFieldCallback)
getIOFuncsIoGetFlags s :: IOFuncs
s = IO (Maybe IOFuncsIoGetFlagsFieldCallback)
-> m (Maybe IOFuncsIoGetFlagsFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe IOFuncsIoGetFlagsFieldCallback)
 -> m (Maybe IOFuncsIoGetFlagsFieldCallback))
-> IO (Maybe IOFuncsIoGetFlagsFieldCallback)
-> m (Maybe IOFuncsIoGetFlagsFieldCallback)
forall a b. (a -> b) -> a -> b
$ IOFuncs
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoGetFlagsFieldCallback))
-> IO (Maybe IOFuncsIoGetFlagsFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO (Maybe IOFuncsIoGetFlagsFieldCallback))
 -> IO (Maybe IOFuncsIoGetFlagsFieldCallback))
-> (Ptr IOFuncs -> IO (Maybe IOFuncsIoGetFlagsFieldCallback))
-> IO (Maybe IOFuncsIoGetFlagsFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    FunPtr C_IOFuncsIoGetFlagsFieldCallback
val <- Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)
-> IO (FunPtr C_IOFuncsIoGetFlagsFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 56) :: IO (FunPtr GLib.Callbacks.C_IOFuncsIoGetFlagsFieldCallback)
    Maybe IOFuncsIoGetFlagsFieldCallback
result <- FunPtr C_IOFuncsIoGetFlagsFieldCallback
-> (FunPtr C_IOFuncsIoGetFlagsFieldCallback
    -> IO IOFuncsIoGetFlagsFieldCallback)
-> IO (Maybe IOFuncsIoGetFlagsFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_IOFuncsIoGetFlagsFieldCallback
val ((FunPtr C_IOFuncsIoGetFlagsFieldCallback
  -> IO IOFuncsIoGetFlagsFieldCallback)
 -> IO (Maybe IOFuncsIoGetFlagsFieldCallback))
-> (FunPtr C_IOFuncsIoGetFlagsFieldCallback
    -> IO IOFuncsIoGetFlagsFieldCallback)
-> IO (Maybe IOFuncsIoGetFlagsFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr C_IOFuncsIoGetFlagsFieldCallback
val' -> do
        let val'' :: IOFuncsIoGetFlagsFieldCallback
val'' = FunPtr C_IOFuncsIoGetFlagsFieldCallback
-> IOFuncsIoGetFlagsFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_IOFuncsIoGetFlagsFieldCallback -> IOChannel -> m [IOFlags]
GLib.Callbacks.dynamic_IOFuncsIoGetFlagsFieldCallback FunPtr C_IOFuncsIoGetFlagsFieldCallback
val'
        IOFuncsIoGetFlagsFieldCallback -> IO IOFuncsIoGetFlagsFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return IOFuncsIoGetFlagsFieldCallback
val''
    Maybe IOFuncsIoGetFlagsFieldCallback
-> IO (Maybe IOFuncsIoGetFlagsFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe IOFuncsIoGetFlagsFieldCallback
result

{- |
Set the value of the “@io_get_flags@” field.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to

@
'Data.GI.Base.Attributes.set' iOFuncs [ #ioGetFlags 'Data.GI.Base.Attributes.:=' value ]
@
-}
setIOFuncsIoGetFlags :: MonadIO m => IOFuncs -> FunPtr GLib.Callbacks.C_IOFuncsIoGetFlagsFieldCallback -> m ()
setIOFuncsIoGetFlags :: IOFuncs -> FunPtr C_IOFuncsIoGetFlagsFieldCallback -> m ()
setIOFuncsIoGetFlags s :: IOFuncs
s val :: FunPtr C_IOFuncsIoGetFlagsFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)
-> FunPtr C_IOFuncsIoGetFlagsFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 56) (FunPtr C_IOFuncsIoGetFlagsFieldCallback
val :: FunPtr GLib.Callbacks.C_IOFuncsIoGetFlagsFieldCallback)

{- |
Set the value of the “@io_get_flags@” 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' #ioGetFlags
@
-}
clearIOFuncsIoGetFlags :: MonadIO m => IOFuncs -> m ()
clearIOFuncsIoGetFlags :: IOFuncs -> m ()
clearIOFuncsIoGetFlags s :: IOFuncs
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ IOFuncs -> (Ptr IOFuncs -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr IOFuncs
s ((Ptr IOFuncs -> IO ()) -> IO ())
-> (Ptr IOFuncs -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr IOFuncs
ptr -> do
    Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)
-> FunPtr C_IOFuncsIoGetFlagsFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr IOFuncs
ptr Ptr IOFuncs -> Int -> Ptr (FunPtr C_IOFuncsIoGetFlagsFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 56) (FunPtr C_IOFuncsIoGetFlagsFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_IOFuncsIoGetFlagsFieldCallback)

#if ENABLE_OVERLOADING
data IOFuncsIoGetFlagsFieldInfo
instance AttrInfo IOFuncsIoGetFlagsFieldInfo where
    type AttrAllowedOps IOFuncsIoGetFlagsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint IOFuncsIoGetFlagsFieldInfo = (~) (FunPtr GLib.Callbacks.C_IOFuncsIoGetFlagsFieldCallback)
    type AttrBaseTypeConstraint IOFuncsIoGetFlagsFieldInfo = (~) IOFuncs
    type AttrGetType IOFuncsIoGetFlagsFieldInfo = Maybe GLib.Callbacks.IOFuncsIoGetFlagsFieldCallback
    type AttrLabel IOFuncsIoGetFlagsFieldInfo = "io_get_flags"
    type AttrOrigin IOFuncsIoGetFlagsFieldInfo = IOFuncs
    attrGet _ = getIOFuncsIoGetFlags
    attrSet _ = setIOFuncsIoGetFlags
    attrConstruct = undefined
    attrClear _ = clearIOFuncsIoGetFlags

iOFuncs_ioGetFlags :: AttrLabelProxy "ioGetFlags"
iOFuncs_ioGetFlags = AttrLabelProxy

#endif



#if ENABLE_OVERLOADING
instance O.HasAttributeList IOFuncs
type instance O.AttributeList IOFuncs = IOFuncsAttributeList
type IOFuncsAttributeList = ('[ '("ioRead", IOFuncsIoReadFieldInfo), '("ioWrite", IOFuncsIoWriteFieldInfo), '("ioSeek", IOFuncsIoSeekFieldInfo), '("ioClose", IOFuncsIoCloseFieldInfo), '("ioCreateWatch", IOFuncsIoCreateWatchFieldInfo), '("ioFree", IOFuncsIoFreeFieldInfo), '("ioSetFlags", IOFuncsIoSetFlagsFieldInfo), '("ioGetFlags", IOFuncsIoGetFlagsFieldInfo)] :: [(Symbol, *)])
#endif

#if ENABLE_OVERLOADING
type family ResolveIOFuncsMethod (t :: Symbol) (o :: *) :: * where
    ResolveIOFuncsMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveIOFuncsMethod t IOFuncs, O.MethodInfo info IOFuncs p) => O.IsLabelProxy t (IOFuncs -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveIOFuncsMethod t IOFuncs, O.MethodInfo info IOFuncs p) => O.IsLabel t (IOFuncs -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
    fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif

#endif