#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.GLib.Structs.MemVTable
(
MemVTable(..) ,
newZeroMemVTable ,
noMemVTable ,
clearMemVTableCalloc ,
getMemVTableCalloc ,
#if ENABLE_OVERLOADING
memVTable_calloc ,
#endif
setMemVTableCalloc ,
clearMemVTableFree ,
getMemVTableFree ,
#if ENABLE_OVERLOADING
memVTable_free ,
#endif
setMemVTableFree ,
clearMemVTableMalloc ,
getMemVTableMalloc ,
#if ENABLE_OVERLOADING
memVTable_malloc ,
#endif
setMemVTableMalloc ,
clearMemVTableRealloc ,
getMemVTableRealloc ,
#if ENABLE_OVERLOADING
memVTable_realloc ,
#endif
setMemVTableRealloc ,
clearMemVTableTryMalloc ,
getMemVTableTryMalloc ,
#if ENABLE_OVERLOADING
memVTable_tryMalloc ,
#endif
setMemVTableTryMalloc ,
clearMemVTableTryRealloc ,
getMemVTableTryRealloc ,
#if ENABLE_OVERLOADING
memVTable_tryRealloc ,
#endif
setMemVTableTryRealloc ,
) 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
newtype MemVTable = MemVTable (ManagedPtr MemVTable)
instance WrappedPtr MemVTable where
wrappedPtrCalloc :: IO (Ptr MemVTable)
wrappedPtrCalloc = Int -> IO (Ptr MemVTable)
forall a. Int -> IO (Ptr a)
callocBytes 48
wrappedPtrCopy :: MemVTable -> IO MemVTable
wrappedPtrCopy = \p :: MemVTable
p -> MemVTable -> (Ptr MemVTable -> IO MemVTable) -> IO MemVTable
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
p (Int -> Ptr MemVTable -> IO (Ptr MemVTable)
forall a. WrappedPtr a => Int -> Ptr a -> IO (Ptr a)
copyBytes 48 (Ptr MemVTable -> IO (Ptr MemVTable))
-> (Ptr MemVTable -> IO MemVTable) -> Ptr MemVTable -> IO MemVTable
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ManagedPtr MemVTable -> MemVTable)
-> Ptr MemVTable -> IO MemVTable
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr MemVTable -> MemVTable
MemVTable)
wrappedPtrFree :: Maybe (FunPtr (Ptr MemVTable -> IO ()))
wrappedPtrFree = FunPtr (Ptr MemVTable -> IO ())
-> Maybe (FunPtr (Ptr MemVTable -> IO ()))
forall a. a -> Maybe a
Just FunPtr (Ptr MemVTable -> IO ())
forall a. FunPtr (Ptr a -> IO ())
ptr_to_g_free
newZeroMemVTable :: MonadIO m => m MemVTable
newZeroMemVTable :: m MemVTable
newZeroMemVTable = IO MemVTable -> m MemVTable
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO MemVTable -> m MemVTable) -> IO MemVTable -> m MemVTable
forall a b. (a -> b) -> a -> b
$ IO (Ptr MemVTable)
forall a. WrappedPtr a => IO (Ptr a)
wrappedPtrCalloc IO (Ptr MemVTable)
-> (Ptr MemVTable -> IO MemVTable) -> IO MemVTable
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr MemVTable -> MemVTable)
-> Ptr MemVTable -> IO MemVTable
forall a.
(HasCallStack, WrappedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr MemVTable -> MemVTable
MemVTable
instance tag ~ 'AttrSet => Constructible MemVTable tag where
new :: (ManagedPtr MemVTable -> MemVTable)
-> [AttrOp MemVTable tag] -> m MemVTable
new _ attrs :: [AttrOp MemVTable tag]
attrs = do
MemVTable
o <- m MemVTable
forall (m :: * -> *). MonadIO m => m MemVTable
newZeroMemVTable
MemVTable -> [AttrOp MemVTable 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set MemVTable
o [AttrOp MemVTable tag]
[AttrOp MemVTable 'AttrSet]
attrs
MemVTable -> m MemVTable
forall (m :: * -> *) a. Monad m => a -> m a
return MemVTable
o
noMemVTable :: Maybe MemVTable
noMemVTable :: Maybe MemVTable
noMemVTable = Maybe MemVTable
forall a. Maybe a
Nothing
getMemVTableMalloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableMallocFieldCallback)
getMemVTableMalloc :: MemVTable -> m (Maybe MemVTableMallocFieldCallback)
getMemVTableMalloc s :: MemVTable
s = IO (Maybe MemVTableMallocFieldCallback)
-> m (Maybe MemVTableMallocFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MemVTableMallocFieldCallback)
-> m (Maybe MemVTableMallocFieldCallback))
-> IO (Maybe MemVTableMallocFieldCallback)
-> m (Maybe MemVTableMallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ MemVTable
-> (Ptr MemVTable -> IO (Maybe MemVTableMallocFieldCallback))
-> IO (Maybe MemVTableMallocFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO (Maybe MemVTableMallocFieldCallback))
-> IO (Maybe MemVTableMallocFieldCallback))
-> (Ptr MemVTable -> IO (Maybe MemVTableMallocFieldCallback))
-> IO (Maybe MemVTableMallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
FunPtr MemVTableMallocFieldCallback
val <- Ptr (FunPtr MemVTableMallocFieldCallback)
-> IO (FunPtr MemVTableMallocFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableMallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO (FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback)
Maybe MemVTableMallocFieldCallback
result <- FunPtr MemVTableMallocFieldCallback
-> (FunPtr MemVTableMallocFieldCallback
-> IO MemVTableMallocFieldCallback)
-> IO (Maybe MemVTableMallocFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr MemVTableMallocFieldCallback
val ((FunPtr MemVTableMallocFieldCallback
-> IO MemVTableMallocFieldCallback)
-> IO (Maybe MemVTableMallocFieldCallback))
-> (FunPtr MemVTableMallocFieldCallback
-> IO MemVTableMallocFieldCallback)
-> IO (Maybe MemVTableMallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr MemVTableMallocFieldCallback
val' -> do
let val'' :: MemVTableMallocFieldCallback
val'' = FunPtr MemVTableMallocFieldCallback -> MemVTableMallocFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr MemVTableMallocFieldCallback -> Word64 -> m (Ptr ())
GLib.Callbacks.dynamic_MemVTableMallocFieldCallback FunPtr MemVTableMallocFieldCallback
val'
MemVTableMallocFieldCallback -> IO MemVTableMallocFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return MemVTableMallocFieldCallback
val''
Maybe MemVTableMallocFieldCallback
-> IO (Maybe MemVTableMallocFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MemVTableMallocFieldCallback
result
setMemVTableMalloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback -> m ()
setMemVTableMalloc :: MemVTable -> FunPtr MemVTableMallocFieldCallback -> m ()
setMemVTableMalloc s :: MemVTable
s val :: FunPtr MemVTableMallocFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableMallocFieldCallback)
-> FunPtr MemVTableMallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableMallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (FunPtr MemVTableMallocFieldCallback
val :: FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback)
clearMemVTableMalloc :: MonadIO m => MemVTable -> m ()
clearMemVTableMalloc :: MemVTable -> m ()
clearMemVTableMalloc s :: MemVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableMallocFieldCallback)
-> FunPtr MemVTableMallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableMallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (FunPtr MemVTableMallocFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback)
#if ENABLE_OVERLOADING
data MemVTableMallocFieldInfo
instance AttrInfo MemVTableMallocFieldInfo where
type AttrAllowedOps MemVTableMallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MemVTableMallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableMallocFieldCallback)
type AttrBaseTypeConstraint MemVTableMallocFieldInfo = (~) MemVTable
type AttrGetType MemVTableMallocFieldInfo = Maybe GLib.Callbacks.MemVTableMallocFieldCallback
type AttrLabel MemVTableMallocFieldInfo = "malloc"
type AttrOrigin MemVTableMallocFieldInfo = MemVTable
attrGet _ = getMemVTableMalloc
attrSet _ = setMemVTableMalloc
attrConstruct = undefined
attrClear _ = clearMemVTableMalloc
memVTable_malloc :: AttrLabelProxy "malloc"
memVTable_malloc = AttrLabelProxy
#endif
getMemVTableRealloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableReallocFieldCallback)
getMemVTableRealloc :: MemVTable -> m (Maybe MemVTableReallocFieldCallback)
getMemVTableRealloc s :: MemVTable
s = IO (Maybe MemVTableReallocFieldCallback)
-> m (Maybe MemVTableReallocFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MemVTableReallocFieldCallback)
-> m (Maybe MemVTableReallocFieldCallback))
-> IO (Maybe MemVTableReallocFieldCallback)
-> m (Maybe MemVTableReallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ MemVTable
-> (Ptr MemVTable -> IO (Maybe MemVTableReallocFieldCallback))
-> IO (Maybe MemVTableReallocFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO (Maybe MemVTableReallocFieldCallback))
-> IO (Maybe MemVTableReallocFieldCallback))
-> (Ptr MemVTable -> IO (Maybe MemVTableReallocFieldCallback))
-> IO (Maybe MemVTableReallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
FunPtr MemVTableReallocFieldCallback
val <- Ptr (FunPtr MemVTableReallocFieldCallback)
-> IO (FunPtr MemVTableReallocFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableReallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO (FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback)
Maybe MemVTableReallocFieldCallback
result <- FunPtr MemVTableReallocFieldCallback
-> (FunPtr MemVTableReallocFieldCallback
-> IO MemVTableReallocFieldCallback)
-> IO (Maybe MemVTableReallocFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr MemVTableReallocFieldCallback
val ((FunPtr MemVTableReallocFieldCallback
-> IO MemVTableReallocFieldCallback)
-> IO (Maybe MemVTableReallocFieldCallback))
-> (FunPtr MemVTableReallocFieldCallback
-> IO MemVTableReallocFieldCallback)
-> IO (Maybe MemVTableReallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr MemVTableReallocFieldCallback
val' -> do
let val'' :: MemVTableReallocFieldCallback
val'' = FunPtr MemVTableReallocFieldCallback
-> MemVTableReallocFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr MemVTableReallocFieldCallback
-> Ptr () -> Word64 -> m (Ptr ())
GLib.Callbacks.dynamic_MemVTableReallocFieldCallback FunPtr MemVTableReallocFieldCallback
val'
MemVTableReallocFieldCallback -> IO MemVTableReallocFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return MemVTableReallocFieldCallback
val''
Maybe MemVTableReallocFieldCallback
-> IO (Maybe MemVTableReallocFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MemVTableReallocFieldCallback
result
setMemVTableRealloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback -> m ()
setMemVTableRealloc :: MemVTable -> FunPtr MemVTableReallocFieldCallback -> m ()
setMemVTableRealloc s :: MemVTable
s val :: FunPtr MemVTableReallocFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableReallocFieldCallback)
-> FunPtr MemVTableReallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableReallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (FunPtr MemVTableReallocFieldCallback
val :: FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback)
clearMemVTableRealloc :: MonadIO m => MemVTable -> m ()
clearMemVTableRealloc :: MemVTable -> m ()
clearMemVTableRealloc s :: MemVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableReallocFieldCallback)
-> FunPtr MemVTableReallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableReallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (FunPtr MemVTableReallocFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback)
#if ENABLE_OVERLOADING
data MemVTableReallocFieldInfo
instance AttrInfo MemVTableReallocFieldInfo where
type AttrAllowedOps MemVTableReallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MemVTableReallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableReallocFieldCallback)
type AttrBaseTypeConstraint MemVTableReallocFieldInfo = (~) MemVTable
type AttrGetType MemVTableReallocFieldInfo = Maybe GLib.Callbacks.MemVTableReallocFieldCallback
type AttrLabel MemVTableReallocFieldInfo = "realloc"
type AttrOrigin MemVTableReallocFieldInfo = MemVTable
attrGet _ = getMemVTableRealloc
attrSet _ = setMemVTableRealloc
attrConstruct = undefined
attrClear _ = clearMemVTableRealloc
memVTable_realloc :: AttrLabelProxy "realloc"
memVTable_realloc = AttrLabelProxy
#endif
getMemVTableFree :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableFreeFieldCallback)
getMemVTableFree :: MemVTable -> m (Maybe MemVTableFreeFieldCallback)
getMemVTableFree s :: MemVTable
s = IO (Maybe MemVTableFreeFieldCallback)
-> m (Maybe MemVTableFreeFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MemVTableFreeFieldCallback)
-> m (Maybe MemVTableFreeFieldCallback))
-> IO (Maybe MemVTableFreeFieldCallback)
-> m (Maybe MemVTableFreeFieldCallback)
forall a b. (a -> b) -> a -> b
$ MemVTable
-> (Ptr MemVTable -> IO (Maybe MemVTableFreeFieldCallback))
-> IO (Maybe MemVTableFreeFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO (Maybe MemVTableFreeFieldCallback))
-> IO (Maybe MemVTableFreeFieldCallback))
-> (Ptr MemVTable -> IO (Maybe MemVTableFreeFieldCallback))
-> IO (Maybe MemVTableFreeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
FunPtr MemVTableFreeFieldCallback
val <- Ptr (FunPtr MemVTableFreeFieldCallback)
-> IO (FunPtr MemVTableFreeFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableFreeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO (FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback)
Maybe MemVTableFreeFieldCallback
result <- FunPtr MemVTableFreeFieldCallback
-> (FunPtr MemVTableFreeFieldCallback
-> IO MemVTableFreeFieldCallback)
-> IO (Maybe MemVTableFreeFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr MemVTableFreeFieldCallback
val ((FunPtr MemVTableFreeFieldCallback
-> IO MemVTableFreeFieldCallback)
-> IO (Maybe MemVTableFreeFieldCallback))
-> (FunPtr MemVTableFreeFieldCallback
-> IO MemVTableFreeFieldCallback)
-> IO (Maybe MemVTableFreeFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr MemVTableFreeFieldCallback
val' -> do
let val'' :: MemVTableFreeFieldCallback
val'' = FunPtr MemVTableFreeFieldCallback -> MemVTableFreeFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr MemVTableFreeFieldCallback -> Ptr () -> m ()
GLib.Callbacks.dynamic_MemVTableFreeFieldCallback FunPtr MemVTableFreeFieldCallback
val'
MemVTableFreeFieldCallback -> IO MemVTableFreeFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return MemVTableFreeFieldCallback
val''
Maybe MemVTableFreeFieldCallback
-> IO (Maybe MemVTableFreeFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MemVTableFreeFieldCallback
result
setMemVTableFree :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback -> m ()
setMemVTableFree :: MemVTable -> FunPtr MemVTableFreeFieldCallback -> m ()
setMemVTableFree s :: MemVTable
s val :: FunPtr MemVTableFreeFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableFreeFieldCallback)
-> FunPtr MemVTableFreeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableFreeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (FunPtr MemVTableFreeFieldCallback
val :: FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback)
clearMemVTableFree :: MonadIO m => MemVTable -> m ()
clearMemVTableFree :: MemVTable -> m ()
clearMemVTableFree s :: MemVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableFreeFieldCallback)
-> FunPtr MemVTableFreeFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableFreeFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (FunPtr MemVTableFreeFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback)
#if ENABLE_OVERLOADING
data MemVTableFreeFieldInfo
instance AttrInfo MemVTableFreeFieldInfo where
type AttrAllowedOps MemVTableFreeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MemVTableFreeFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableFreeFieldCallback)
type AttrBaseTypeConstraint MemVTableFreeFieldInfo = (~) MemVTable
type AttrGetType MemVTableFreeFieldInfo = Maybe GLib.Callbacks.MemVTableFreeFieldCallback
type AttrLabel MemVTableFreeFieldInfo = "free"
type AttrOrigin MemVTableFreeFieldInfo = MemVTable
attrGet _ = getMemVTableFree
attrSet _ = setMemVTableFree
attrConstruct = undefined
attrClear _ = clearMemVTableFree
memVTable_free :: AttrLabelProxy "free"
memVTable_free = AttrLabelProxy
#endif
getMemVTableCalloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableCallocFieldCallback)
getMemVTableCalloc :: MemVTable -> m (Maybe MemVTableCallocFieldCallback)
getMemVTableCalloc s :: MemVTable
s = IO (Maybe MemVTableCallocFieldCallback)
-> m (Maybe MemVTableCallocFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MemVTableCallocFieldCallback)
-> m (Maybe MemVTableCallocFieldCallback))
-> IO (Maybe MemVTableCallocFieldCallback)
-> m (Maybe MemVTableCallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ MemVTable
-> (Ptr MemVTable -> IO (Maybe MemVTableCallocFieldCallback))
-> IO (Maybe MemVTableCallocFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO (Maybe MemVTableCallocFieldCallback))
-> IO (Maybe MemVTableCallocFieldCallback))
-> (Ptr MemVTable -> IO (Maybe MemVTableCallocFieldCallback))
-> IO (Maybe MemVTableCallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
FunPtr MemVTableCallocFieldCallback
val <- Ptr (FunPtr MemVTableCallocFieldCallback)
-> IO (FunPtr MemVTableCallocFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableCallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO (FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback)
Maybe MemVTableCallocFieldCallback
result <- FunPtr MemVTableCallocFieldCallback
-> (FunPtr MemVTableCallocFieldCallback
-> IO MemVTableCallocFieldCallback)
-> IO (Maybe MemVTableCallocFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr MemVTableCallocFieldCallback
val ((FunPtr MemVTableCallocFieldCallback
-> IO MemVTableCallocFieldCallback)
-> IO (Maybe MemVTableCallocFieldCallback))
-> (FunPtr MemVTableCallocFieldCallback
-> IO MemVTableCallocFieldCallback)
-> IO (Maybe MemVTableCallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr MemVTableCallocFieldCallback
val' -> do
let val'' :: MemVTableCallocFieldCallback
val'' = FunPtr MemVTableCallocFieldCallback -> MemVTableCallocFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr MemVTableCallocFieldCallback
-> Word64 -> Word64 -> m (Ptr ())
GLib.Callbacks.dynamic_MemVTableCallocFieldCallback FunPtr MemVTableCallocFieldCallback
val'
MemVTableCallocFieldCallback -> IO MemVTableCallocFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return MemVTableCallocFieldCallback
val''
Maybe MemVTableCallocFieldCallback
-> IO (Maybe MemVTableCallocFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MemVTableCallocFieldCallback
result
setMemVTableCalloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback -> m ()
setMemVTableCalloc :: MemVTable -> FunPtr MemVTableCallocFieldCallback -> m ()
setMemVTableCalloc s :: MemVTable
s val :: FunPtr MemVTableCallocFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableCallocFieldCallback)
-> FunPtr MemVTableCallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableCallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (FunPtr MemVTableCallocFieldCallback
val :: FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback)
clearMemVTableCalloc :: MonadIO m => MemVTable -> m ()
clearMemVTableCalloc :: MemVTable -> m ()
clearMemVTableCalloc s :: MemVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableCallocFieldCallback)
-> FunPtr MemVTableCallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableCallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (FunPtr MemVTableCallocFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback)
#if ENABLE_OVERLOADING
data MemVTableCallocFieldInfo
instance AttrInfo MemVTableCallocFieldInfo where
type AttrAllowedOps MemVTableCallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MemVTableCallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableCallocFieldCallback)
type AttrBaseTypeConstraint MemVTableCallocFieldInfo = (~) MemVTable
type AttrGetType MemVTableCallocFieldInfo = Maybe GLib.Callbacks.MemVTableCallocFieldCallback
type AttrLabel MemVTableCallocFieldInfo = "calloc"
type AttrOrigin MemVTableCallocFieldInfo = MemVTable
attrGet _ = getMemVTableCalloc
attrSet _ = setMemVTableCalloc
attrConstruct = undefined
attrClear _ = clearMemVTableCalloc
memVTable_calloc :: AttrLabelProxy "calloc"
memVTable_calloc = AttrLabelProxy
#endif
getMemVTableTryMalloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableTryMallocFieldCallback)
getMemVTableTryMalloc :: MemVTable -> m (Maybe MemVTableMallocFieldCallback)
getMemVTableTryMalloc s :: MemVTable
s = IO (Maybe MemVTableMallocFieldCallback)
-> m (Maybe MemVTableMallocFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MemVTableMallocFieldCallback)
-> m (Maybe MemVTableMallocFieldCallback))
-> IO (Maybe MemVTableMallocFieldCallback)
-> m (Maybe MemVTableMallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ MemVTable
-> (Ptr MemVTable -> IO (Maybe MemVTableMallocFieldCallback))
-> IO (Maybe MemVTableMallocFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO (Maybe MemVTableMallocFieldCallback))
-> IO (Maybe MemVTableMallocFieldCallback))
-> (Ptr MemVTable -> IO (Maybe MemVTableMallocFieldCallback))
-> IO (Maybe MemVTableMallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
FunPtr MemVTableMallocFieldCallback
val <- Ptr (FunPtr MemVTableMallocFieldCallback)
-> IO (FunPtr MemVTableMallocFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableMallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) :: IO (FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback)
Maybe MemVTableMallocFieldCallback
result <- FunPtr MemVTableMallocFieldCallback
-> (FunPtr MemVTableMallocFieldCallback
-> IO MemVTableMallocFieldCallback)
-> IO (Maybe MemVTableMallocFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr MemVTableMallocFieldCallback
val ((FunPtr MemVTableMallocFieldCallback
-> IO MemVTableMallocFieldCallback)
-> IO (Maybe MemVTableMallocFieldCallback))
-> (FunPtr MemVTableMallocFieldCallback
-> IO MemVTableMallocFieldCallback)
-> IO (Maybe MemVTableMallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr MemVTableMallocFieldCallback
val' -> do
let val'' :: MemVTableMallocFieldCallback
val'' = FunPtr MemVTableMallocFieldCallback -> MemVTableMallocFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr MemVTableMallocFieldCallback -> Word64 -> m (Ptr ())
GLib.Callbacks.dynamic_MemVTableTryMallocFieldCallback FunPtr MemVTableMallocFieldCallback
val'
MemVTableMallocFieldCallback -> IO MemVTableMallocFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return MemVTableMallocFieldCallback
val''
Maybe MemVTableMallocFieldCallback
-> IO (Maybe MemVTableMallocFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MemVTableMallocFieldCallback
result
setMemVTableTryMalloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback -> m ()
setMemVTableTryMalloc :: MemVTable -> FunPtr MemVTableMallocFieldCallback -> m ()
setMemVTableTryMalloc s :: MemVTable
s val :: FunPtr MemVTableMallocFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableMallocFieldCallback)
-> FunPtr MemVTableMallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableMallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (FunPtr MemVTableMallocFieldCallback
val :: FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback)
clearMemVTableTryMalloc :: MonadIO m => MemVTable -> m ()
clearMemVTableTryMalloc :: MemVTable -> m ()
clearMemVTableTryMalloc s :: MemVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableMallocFieldCallback)
-> FunPtr MemVTableMallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableMallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (FunPtr MemVTableMallocFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback)
#if ENABLE_OVERLOADING
data MemVTableTryMallocFieldInfo
instance AttrInfo MemVTableTryMallocFieldInfo where
type AttrAllowedOps MemVTableTryMallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MemVTableTryMallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableTryMallocFieldCallback)
type AttrBaseTypeConstraint MemVTableTryMallocFieldInfo = (~) MemVTable
type AttrGetType MemVTableTryMallocFieldInfo = Maybe GLib.Callbacks.MemVTableTryMallocFieldCallback
type AttrLabel MemVTableTryMallocFieldInfo = "try_malloc"
type AttrOrigin MemVTableTryMallocFieldInfo = MemVTable
attrGet _ = getMemVTableTryMalloc
attrSet _ = setMemVTableTryMalloc
attrConstruct = undefined
attrClear _ = clearMemVTableTryMalloc
memVTable_tryMalloc :: AttrLabelProxy "tryMalloc"
memVTable_tryMalloc = AttrLabelProxy
#endif
getMemVTableTryRealloc :: MonadIO m => MemVTable -> m (Maybe GLib.Callbacks.MemVTableTryReallocFieldCallback)
getMemVTableTryRealloc :: MemVTable -> m (Maybe MemVTableReallocFieldCallback)
getMemVTableTryRealloc s :: MemVTable
s = IO (Maybe MemVTableReallocFieldCallback)
-> m (Maybe MemVTableReallocFieldCallback)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe MemVTableReallocFieldCallback)
-> m (Maybe MemVTableReallocFieldCallback))
-> IO (Maybe MemVTableReallocFieldCallback)
-> m (Maybe MemVTableReallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ MemVTable
-> (Ptr MemVTable -> IO (Maybe MemVTableReallocFieldCallback))
-> IO (Maybe MemVTableReallocFieldCallback)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO (Maybe MemVTableReallocFieldCallback))
-> IO (Maybe MemVTableReallocFieldCallback))
-> (Ptr MemVTable -> IO (Maybe MemVTableReallocFieldCallback))
-> IO (Maybe MemVTableReallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
FunPtr MemVTableReallocFieldCallback
val <- Ptr (FunPtr MemVTableReallocFieldCallback)
-> IO (FunPtr MemVTableReallocFieldCallback)
forall a. Storable a => Ptr a -> IO a
peek (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableReallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) :: IO (FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback)
Maybe MemVTableReallocFieldCallback
result <- FunPtr MemVTableReallocFieldCallback
-> (FunPtr MemVTableReallocFieldCallback
-> IO MemVTableReallocFieldCallback)
-> IO (Maybe MemVTableReallocFieldCallback)
forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr MemVTableReallocFieldCallback
val ((FunPtr MemVTableReallocFieldCallback
-> IO MemVTableReallocFieldCallback)
-> IO (Maybe MemVTableReallocFieldCallback))
-> (FunPtr MemVTableReallocFieldCallback
-> IO MemVTableReallocFieldCallback)
-> IO (Maybe MemVTableReallocFieldCallback)
forall a b. (a -> b) -> a -> b
$ \val' :: FunPtr MemVTableReallocFieldCallback
val' -> do
let val'' :: MemVTableReallocFieldCallback
val'' = FunPtr MemVTableReallocFieldCallback
-> MemVTableReallocFieldCallback
forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr MemVTableReallocFieldCallback
-> Ptr () -> Word64 -> m (Ptr ())
GLib.Callbacks.dynamic_MemVTableTryReallocFieldCallback FunPtr MemVTableReallocFieldCallback
val'
MemVTableReallocFieldCallback -> IO MemVTableReallocFieldCallback
forall (m :: * -> *) a. Monad m => a -> m a
return MemVTableReallocFieldCallback
val''
Maybe MemVTableReallocFieldCallback
-> IO (Maybe MemVTableReallocFieldCallback)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe MemVTableReallocFieldCallback
result
setMemVTableTryRealloc :: MonadIO m => MemVTable -> FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback -> m ()
setMemVTableTryRealloc :: MemVTable -> FunPtr MemVTableReallocFieldCallback -> m ()
setMemVTableTryRealloc s :: MemVTable
s val :: FunPtr MemVTableReallocFieldCallback
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableReallocFieldCallback)
-> FunPtr MemVTableReallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableReallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (FunPtr MemVTableReallocFieldCallback
val :: FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback)
clearMemVTableTryRealloc :: MonadIO m => MemVTable -> m ()
clearMemVTableTryRealloc :: MemVTable -> m ()
clearMemVTableTryRealloc s :: MemVTable
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ MemVTable -> (Ptr MemVTable -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr MemVTable
s ((Ptr MemVTable -> IO ()) -> IO ())
-> (Ptr MemVTable -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr MemVTable
ptr -> do
Ptr (FunPtr MemVTableReallocFieldCallback)
-> FunPtr MemVTableReallocFieldCallback -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr MemVTable
ptr Ptr MemVTable -> Int -> Ptr (FunPtr MemVTableReallocFieldCallback)
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (FunPtr MemVTableReallocFieldCallback
forall a. FunPtr a
FP.nullFunPtr :: FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback)
#if ENABLE_OVERLOADING
data MemVTableTryReallocFieldInfo
instance AttrInfo MemVTableTryReallocFieldInfo where
type AttrAllowedOps MemVTableTryReallocFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint MemVTableTryReallocFieldInfo = (~) (FunPtr GLib.Callbacks.C_MemVTableTryReallocFieldCallback)
type AttrBaseTypeConstraint MemVTableTryReallocFieldInfo = (~) MemVTable
type AttrGetType MemVTableTryReallocFieldInfo = Maybe GLib.Callbacks.MemVTableTryReallocFieldCallback
type AttrLabel MemVTableTryReallocFieldInfo = "try_realloc"
type AttrOrigin MemVTableTryReallocFieldInfo = MemVTable
attrGet _ = getMemVTableTryRealloc
attrSet _ = setMemVTableTryRealloc
attrConstruct = undefined
attrClear _ = clearMemVTableTryRealloc
memVTable_tryRealloc :: AttrLabelProxy "tryRealloc"
memVTable_tryRealloc = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList MemVTable
type instance O.AttributeList MemVTable = MemVTableAttributeList
type MemVTableAttributeList = ('[ '("malloc", MemVTableMallocFieldInfo), '("realloc", MemVTableReallocFieldInfo), '("free", MemVTableFreeFieldInfo), '("calloc", MemVTableCallocFieldInfo), '("tryMalloc", MemVTableTryMallocFieldInfo), '("tryRealloc", MemVTableTryReallocFieldInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
type family ResolveMemVTableMethod (t :: Symbol) (o :: *) :: * where
ResolveMemVTableMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveMemVTableMethod t MemVTable, O.MethodInfo info MemVTable p) => O.IsLabelProxy t (MemVTable -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveMemVTableMethod t MemVTable, O.MethodInfo info MemVTable p) => O.IsLabel t (MemVTable -> 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