{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GObject.Structs.TypeInfo
(
TypeInfo(..) ,
newZeroTypeInfo ,
#if defined(ENABLE_OVERLOADING)
ResolveTypeInfoMethod ,
#endif
clearTypeInfoBaseFinalize ,
getTypeInfoBaseFinalize ,
setTypeInfoBaseFinalize ,
#if defined(ENABLE_OVERLOADING)
typeInfo_baseFinalize ,
#endif
clearTypeInfoBaseInit ,
getTypeInfoBaseInit ,
setTypeInfoBaseInit ,
#if defined(ENABLE_OVERLOADING)
typeInfo_baseInit ,
#endif
clearTypeInfoClassData ,
getTypeInfoClassData ,
setTypeInfoClassData ,
#if defined(ENABLE_OVERLOADING)
typeInfo_classData ,
#endif
clearTypeInfoClassFinalize ,
getTypeInfoClassFinalize ,
setTypeInfoClassFinalize ,
#if defined(ENABLE_OVERLOADING)
typeInfo_classFinalize ,
#endif
clearTypeInfoClassInit ,
getTypeInfoClassInit ,
setTypeInfoClassInit ,
#if defined(ENABLE_OVERLOADING)
typeInfo_classInit ,
#endif
getTypeInfoClassSize ,
setTypeInfoClassSize ,
#if defined(ENABLE_OVERLOADING)
typeInfo_classSize ,
#endif
clearTypeInfoInstanceInit ,
getTypeInfoInstanceInit ,
setTypeInfoInstanceInit ,
#if defined(ENABLE_OVERLOADING)
typeInfo_instanceInit ,
#endif
getTypeInfoInstanceSize ,
setTypeInfoInstanceSize ,
#if defined(ENABLE_OVERLOADING)
typeInfo_instanceSize ,
#endif
getTypeInfoNPreallocs ,
setTypeInfoNPreallocs ,
#if defined(ENABLE_OVERLOADING)
typeInfo_nPreallocs ,
#endif
clearTypeInfoValueTable ,
getTypeInfoValueTable ,
setTypeInfoValueTable ,
#if defined(ENABLE_OVERLOADING)
typeInfo_valueTable ,
#endif
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GObject.Callbacks as GObject.Callbacks
import {-# SOURCE #-} qualified GI.GObject.Structs.TypeValueTable as GObject.TypeValueTable
newtype TypeInfo = TypeInfo (SP.ManagedPtr TypeInfo)
deriving (TypeInfo -> TypeInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TypeInfo -> TypeInfo -> Bool
$c/= :: TypeInfo -> TypeInfo -> Bool
== :: TypeInfo -> TypeInfo -> Bool
$c== :: TypeInfo -> TypeInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype TypeInfo where
toManagedPtr :: TypeInfo -> ManagedPtr TypeInfo
toManagedPtr (TypeInfo ManagedPtr TypeInfo
p) = ManagedPtr TypeInfo
p
instance BoxedPtr TypeInfo where
boxedPtrCopy :: TypeInfo -> IO TypeInfo
boxedPtrCopy = \TypeInfo
p -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr TypeInfo
p (forall a. (HasCallStack, CallocPtr a) => Int -> Ptr a -> IO (Ptr a)
copyBytes Int
36 forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.wrapPtr ManagedPtr TypeInfo -> TypeInfo
TypeInfo)
boxedPtrFree :: TypeInfo -> IO ()
boxedPtrFree = \TypeInfo
x -> forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
SP.withManagedPtr TypeInfo
x forall a. Ptr a -> IO ()
SP.freeMem
instance CallocPtr TypeInfo where
boxedPtrCalloc :: IO (Ptr TypeInfo)
boxedPtrCalloc = forall a. Int -> IO (Ptr a)
callocBytes Int
36
newZeroTypeInfo :: MonadIO m => m TypeInfo
newZeroTypeInfo :: forall (m :: * -> *). MonadIO m => m TypeInfo
newZeroTypeInfo = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. CallocPtr a => IO (Ptr a)
boxedPtrCalloc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapPtr ManagedPtr TypeInfo -> TypeInfo
TypeInfo
instance tag ~ 'AttrSet => Constructible TypeInfo tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr TypeInfo -> TypeInfo)
-> [AttrOp TypeInfo tag] -> m TypeInfo
new ManagedPtr TypeInfo -> TypeInfo
_ [AttrOp TypeInfo tag]
attrs = do
TypeInfo
o <- forall (m :: * -> *). MonadIO m => m TypeInfo
newZeroTypeInfo
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set TypeInfo
o [AttrOp TypeInfo tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return TypeInfo
o
getTypeInfoClassSize :: MonadIO m => TypeInfo -> m Word16
getTypeInfoClassSize :: forall (m :: * -> *). MonadIO m => TypeInfo -> m Word16
getTypeInfoClassSize TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
Word16
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Word16
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
val
setTypeInfoClassSize :: MonadIO m => TypeInfo -> Word16 -> m ()
setTypeInfoClassSize :: forall (m :: * -> *). MonadIO m => TypeInfo -> Word16 -> m ()
setTypeInfoClassSize TypeInfo
s Word16
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Word16
val :: Word16)
#if defined(ENABLE_OVERLOADING)
data TypeInfoClassSizeFieldInfo
instance AttrInfo TypeInfoClassSizeFieldInfo where
type AttrBaseTypeConstraint TypeInfoClassSizeFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoClassSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint TypeInfoClassSizeFieldInfo = (~) Word16
type AttrTransferTypeConstraint TypeInfoClassSizeFieldInfo = (~)Word16
type AttrTransferType TypeInfoClassSizeFieldInfo = Word16
type AttrGetType TypeInfoClassSizeFieldInfo = Word16
type AttrLabel TypeInfoClassSizeFieldInfo = "class_size"
type AttrOrigin TypeInfoClassSizeFieldInfo = TypeInfo
attrGet = getTypeInfoClassSize
attrSet = setTypeInfoClassSize
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.classSize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:classSize"
})
typeInfo_classSize :: AttrLabelProxy "classSize"
typeInfo_classSize = AttrLabelProxy
#endif
getTypeInfoBaseInit :: MonadIO m => TypeInfo -> m (Maybe GObject.Callbacks.BaseInitFunc)
getTypeInfoBaseInit :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> m (Maybe BaseInitFunc)
getTypeInfoBaseInit TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
FunPtr C_BaseInitFunc
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO (FunPtr GObject.Callbacks.C_BaseInitFunc)
Maybe BaseInitFunc
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_BaseInitFunc
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_BaseInitFunc
val' -> do
let val'' :: BaseInitFunc
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_BaseInitFunc -> TypeClass -> m ()
GObject.Callbacks.dynamic_BaseInitFunc FunPtr C_BaseInitFunc
val'
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInitFunc
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInitFunc
result
setTypeInfoBaseInit :: MonadIO m => TypeInfo -> FunPtr GObject.Callbacks.C_BaseInitFunc -> m ()
setTypeInfoBaseInit :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> FunPtr C_BaseInitFunc -> m ()
setTypeInfoBaseInit TypeInfo
s FunPtr C_BaseInitFunc
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (FunPtr C_BaseInitFunc
val :: FunPtr GObject.Callbacks.C_BaseInitFunc)
clearTypeInfoBaseInit :: MonadIO m => TypeInfo -> m ()
clearTypeInfoBaseInit :: forall (m :: * -> *). MonadIO m => TypeInfo -> m ()
clearTypeInfoBaseInit TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_BaseInitFunc)
#if defined(ENABLE_OVERLOADING)
data TypeInfoBaseInitFieldInfo
instance AttrInfo TypeInfoBaseInitFieldInfo where
type AttrBaseTypeConstraint TypeInfoBaseInitFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoBaseInitFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeInfoBaseInitFieldInfo = (~) (FunPtr GObject.Callbacks.C_BaseInitFunc)
type AttrTransferTypeConstraint TypeInfoBaseInitFieldInfo = (~)GObject.Callbacks.BaseInitFunc
type AttrTransferType TypeInfoBaseInitFieldInfo = (FunPtr GObject.Callbacks.C_BaseInitFunc)
type AttrGetType TypeInfoBaseInitFieldInfo = Maybe GObject.Callbacks.BaseInitFunc
type AttrLabel TypeInfoBaseInitFieldInfo = "base_init"
type AttrOrigin TypeInfoBaseInitFieldInfo = TypeInfo
attrGet = getTypeInfoBaseInit
attrSet = setTypeInfoBaseInit
attrConstruct = undefined
attrClear = clearTypeInfoBaseInit
attrTransfer _ v = do
GObject.Callbacks.mk_BaseInitFunc (GObject.Callbacks.wrap_BaseInitFunc Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.baseInit"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:baseInit"
})
typeInfo_baseInit :: AttrLabelProxy "baseInit"
typeInfo_baseInit = AttrLabelProxy
#endif
getTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> m (Maybe GObject.Callbacks.BaseFinalizeFunc)
getTypeInfoBaseFinalize :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> m (Maybe BaseInitFunc)
getTypeInfoBaseFinalize TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
FunPtr C_BaseInitFunc
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (FunPtr GObject.Callbacks.C_BaseFinalizeFunc)
Maybe BaseInitFunc
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_BaseInitFunc
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_BaseInitFunc
val' -> do
let val'' :: BaseInitFunc
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_BaseInitFunc -> TypeClass -> m ()
GObject.Callbacks.dynamic_BaseFinalizeFunc FunPtr C_BaseInitFunc
val'
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInitFunc
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInitFunc
result
setTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> FunPtr GObject.Callbacks.C_BaseFinalizeFunc -> m ()
setTypeInfoBaseFinalize :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> FunPtr C_BaseInitFunc -> m ()
setTypeInfoBaseFinalize TypeInfo
s FunPtr C_BaseInitFunc
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (FunPtr C_BaseInitFunc
val :: FunPtr GObject.Callbacks.C_BaseFinalizeFunc)
clearTypeInfoBaseFinalize :: MonadIO m => TypeInfo -> m ()
clearTypeInfoBaseFinalize :: forall (m :: * -> *). MonadIO m => TypeInfo -> m ()
clearTypeInfoBaseFinalize TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_BaseFinalizeFunc)
#if defined(ENABLE_OVERLOADING)
data TypeInfoBaseFinalizeFieldInfo
instance AttrInfo TypeInfoBaseFinalizeFieldInfo where
type AttrBaseTypeConstraint TypeInfoBaseFinalizeFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoBaseFinalizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeInfoBaseFinalizeFieldInfo = (~) (FunPtr GObject.Callbacks.C_BaseFinalizeFunc)
type AttrTransferTypeConstraint TypeInfoBaseFinalizeFieldInfo = (~)GObject.Callbacks.BaseFinalizeFunc
type AttrTransferType TypeInfoBaseFinalizeFieldInfo = (FunPtr GObject.Callbacks.C_BaseFinalizeFunc)
type AttrGetType TypeInfoBaseFinalizeFieldInfo = Maybe GObject.Callbacks.BaseFinalizeFunc
type AttrLabel TypeInfoBaseFinalizeFieldInfo = "base_finalize"
type AttrOrigin TypeInfoBaseFinalizeFieldInfo = TypeInfo
attrGet = getTypeInfoBaseFinalize
attrSet = setTypeInfoBaseFinalize
attrConstruct = undefined
attrClear = clearTypeInfoBaseFinalize
attrTransfer _ v = do
GObject.Callbacks.mk_BaseFinalizeFunc (GObject.Callbacks.wrap_BaseFinalizeFunc Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.baseFinalize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:baseFinalize"
})
typeInfo_baseFinalize :: AttrLabelProxy "baseFinalize"
typeInfo_baseFinalize = AttrLabelProxy
#endif
getTypeInfoClassInit :: MonadIO m => TypeInfo -> m (Maybe GObject.Callbacks.ClassInitFunc)
getTypeInfoClassInit :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> m (Maybe ClassInitFunc)
getTypeInfoClassInit TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
FunPtr C_ClassInitFunc
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (FunPtr GObject.Callbacks.C_ClassInitFunc)
Maybe ClassInitFunc
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ClassInitFunc
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ClassInitFunc
val' -> do
let val'' :: ClassInitFunc
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_ClassInitFunc -> TypeClass -> Ptr () -> m ()
GObject.Callbacks.dynamic_ClassInitFunc FunPtr C_ClassInitFunc
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ClassInitFunc
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ClassInitFunc
result
setTypeInfoClassInit :: MonadIO m => TypeInfo -> FunPtr GObject.Callbacks.C_ClassInitFunc -> m ()
setTypeInfoClassInit :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> FunPtr C_ClassInitFunc -> m ()
setTypeInfoClassInit TypeInfo
s FunPtr C_ClassInitFunc
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (FunPtr C_ClassInitFunc
val :: FunPtr GObject.Callbacks.C_ClassInitFunc)
clearTypeInfoClassInit :: MonadIO m => TypeInfo -> m ()
clearTypeInfoClassInit :: forall (m :: * -> *). MonadIO m => TypeInfo -> m ()
clearTypeInfoClassInit TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ClassInitFunc)
#if defined(ENABLE_OVERLOADING)
data TypeInfoClassInitFieldInfo
instance AttrInfo TypeInfoClassInitFieldInfo where
type AttrBaseTypeConstraint TypeInfoClassInitFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoClassInitFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeInfoClassInitFieldInfo = (~) (FunPtr GObject.Callbacks.C_ClassInitFunc)
type AttrTransferTypeConstraint TypeInfoClassInitFieldInfo = (~)GObject.Callbacks.ClassInitFunc
type AttrTransferType TypeInfoClassInitFieldInfo = (FunPtr GObject.Callbacks.C_ClassInitFunc)
type AttrGetType TypeInfoClassInitFieldInfo = Maybe GObject.Callbacks.ClassInitFunc
type AttrLabel TypeInfoClassInitFieldInfo = "class_init"
type AttrOrigin TypeInfoClassInitFieldInfo = TypeInfo
attrGet = getTypeInfoClassInit
attrSet = setTypeInfoClassInit
attrConstruct = undefined
attrClear = clearTypeInfoClassInit
attrTransfer _ v = do
GObject.Callbacks.mk_ClassInitFunc (GObject.Callbacks.wrap_ClassInitFunc Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.classInit"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:classInit"
})
typeInfo_classInit :: AttrLabelProxy "classInit"
typeInfo_classInit = AttrLabelProxy
#endif
getTypeInfoClassFinalize :: MonadIO m => TypeInfo -> m (Maybe GObject.Callbacks.ClassFinalizeFunc)
getTypeInfoClassFinalize :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> m (Maybe ClassInitFunc)
getTypeInfoClassFinalize TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
FunPtr C_ClassInitFunc
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (FunPtr GObject.Callbacks.C_ClassFinalizeFunc)
Maybe ClassInitFunc
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_ClassInitFunc
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_ClassInitFunc
val' -> do
let val'' :: ClassInitFunc
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_ClassInitFunc -> TypeClass -> Ptr () -> m ()
GObject.Callbacks.dynamic_ClassFinalizeFunc FunPtr C_ClassInitFunc
val'
forall (m :: * -> *) a. Monad m => a -> m a
return ClassInitFunc
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe ClassInitFunc
result
setTypeInfoClassFinalize :: MonadIO m => TypeInfo -> FunPtr GObject.Callbacks.C_ClassFinalizeFunc -> m ()
setTypeInfoClassFinalize :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> FunPtr C_ClassInitFunc -> m ()
setTypeInfoClassFinalize TypeInfo
s FunPtr C_ClassInitFunc
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (FunPtr C_ClassInitFunc
val :: FunPtr GObject.Callbacks.C_ClassFinalizeFunc)
clearTypeInfoClassFinalize :: MonadIO m => TypeInfo -> m ()
clearTypeInfoClassFinalize :: forall (m :: * -> *). MonadIO m => TypeInfo -> m ()
clearTypeInfoClassFinalize TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_ClassFinalizeFunc)
#if defined(ENABLE_OVERLOADING)
data TypeInfoClassFinalizeFieldInfo
instance AttrInfo TypeInfoClassFinalizeFieldInfo where
type AttrBaseTypeConstraint TypeInfoClassFinalizeFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoClassFinalizeFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeInfoClassFinalizeFieldInfo = (~) (FunPtr GObject.Callbacks.C_ClassFinalizeFunc)
type AttrTransferTypeConstraint TypeInfoClassFinalizeFieldInfo = (~)GObject.Callbacks.ClassFinalizeFunc
type AttrTransferType TypeInfoClassFinalizeFieldInfo = (FunPtr GObject.Callbacks.C_ClassFinalizeFunc)
type AttrGetType TypeInfoClassFinalizeFieldInfo = Maybe GObject.Callbacks.ClassFinalizeFunc
type AttrLabel TypeInfoClassFinalizeFieldInfo = "class_finalize"
type AttrOrigin TypeInfoClassFinalizeFieldInfo = TypeInfo
attrGet = getTypeInfoClassFinalize
attrSet = setTypeInfoClassFinalize
attrConstruct = undefined
attrClear = clearTypeInfoClassFinalize
attrTransfer _ v = do
GObject.Callbacks.mk_ClassFinalizeFunc (GObject.Callbacks.wrap_ClassFinalizeFunc Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.classFinalize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:classFinalize"
})
typeInfo_classFinalize :: AttrLabelProxy "classFinalize"
typeInfo_classFinalize = AttrLabelProxy
#endif
getTypeInfoClassData :: MonadIO m => TypeInfo -> m (Ptr ())
getTypeInfoClassData :: forall (m :: * -> *). MonadIO m => TypeInfo -> m (Ptr ())
getTypeInfoClassData TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
Ptr ()
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO (Ptr ())
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
val
setTypeInfoClassData :: MonadIO m => TypeInfo -> Ptr () -> m ()
setTypeInfoClassData :: forall (m :: * -> *). MonadIO m => TypeInfo -> Ptr () -> m ()
setTypeInfoClassData TypeInfo
s Ptr ()
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Ptr ()
val :: Ptr ())
clearTypeInfoClassData :: MonadIO m => TypeInfo -> m ()
clearTypeInfoClassData :: forall (m :: * -> *). MonadIO m => TypeInfo -> m ()
clearTypeInfoClassData TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (forall a. Ptr a
FP.nullPtr :: Ptr ())
#if defined(ENABLE_OVERLOADING)
data TypeInfoClassDataFieldInfo
instance AttrInfo TypeInfoClassDataFieldInfo where
type AttrBaseTypeConstraint TypeInfoClassDataFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoClassDataFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeInfoClassDataFieldInfo = (~) (Ptr ())
type AttrTransferTypeConstraint TypeInfoClassDataFieldInfo = (~)(Ptr ())
type AttrTransferType TypeInfoClassDataFieldInfo = (Ptr ())
type AttrGetType TypeInfoClassDataFieldInfo = Ptr ()
type AttrLabel TypeInfoClassDataFieldInfo = "class_data"
type AttrOrigin TypeInfoClassDataFieldInfo = TypeInfo
attrGet = getTypeInfoClassData
attrSet = setTypeInfoClassData
attrConstruct = undefined
attrClear = clearTypeInfoClassData
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.classData"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:classData"
})
typeInfo_classData :: AttrLabelProxy "classData"
typeInfo_classData = AttrLabelProxy
#endif
getTypeInfoInstanceSize :: MonadIO m => TypeInfo -> m Word16
getTypeInfoInstanceSize :: forall (m :: * -> *). MonadIO m => TypeInfo -> m Word16
getTypeInfoInstanceSize TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
Word16
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) :: IO Word16
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
val
setTypeInfoInstanceSize :: MonadIO m => TypeInfo -> Word16 -> m ()
setTypeInfoInstanceSize :: forall (m :: * -> *). MonadIO m => TypeInfo -> Word16 -> m ()
setTypeInfoInstanceSize TypeInfo
s Word16
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
24) (Word16
val :: Word16)
#if defined(ENABLE_OVERLOADING)
data TypeInfoInstanceSizeFieldInfo
instance AttrInfo TypeInfoInstanceSizeFieldInfo where
type AttrBaseTypeConstraint TypeInfoInstanceSizeFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoInstanceSizeFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint TypeInfoInstanceSizeFieldInfo = (~) Word16
type AttrTransferTypeConstraint TypeInfoInstanceSizeFieldInfo = (~)Word16
type AttrTransferType TypeInfoInstanceSizeFieldInfo = Word16
type AttrGetType TypeInfoInstanceSizeFieldInfo = Word16
type AttrLabel TypeInfoInstanceSizeFieldInfo = "instance_size"
type AttrOrigin TypeInfoInstanceSizeFieldInfo = TypeInfo
attrGet = getTypeInfoInstanceSize
attrSet = setTypeInfoInstanceSize
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.instanceSize"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:instanceSize"
})
typeInfo_instanceSize :: AttrLabelProxy "instanceSize"
typeInfo_instanceSize = AttrLabelProxy
#endif
getTypeInfoNPreallocs :: MonadIO m => TypeInfo -> m Word16
getTypeInfoNPreallocs :: forall (m :: * -> *). MonadIO m => TypeInfo -> m Word16
getTypeInfoNPreallocs TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
Word16
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
26) :: IO Word16
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
val
setTypeInfoNPreallocs :: MonadIO m => TypeInfo -> Word16 -> m ()
setTypeInfoNPreallocs :: forall (m :: * -> *). MonadIO m => TypeInfo -> Word16 -> m ()
setTypeInfoNPreallocs TypeInfo
s Word16
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
26) (Word16
val :: Word16)
#if defined(ENABLE_OVERLOADING)
data TypeInfoNPreallocsFieldInfo
instance AttrInfo TypeInfoNPreallocsFieldInfo where
type AttrBaseTypeConstraint TypeInfoNPreallocsFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoNPreallocsFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint TypeInfoNPreallocsFieldInfo = (~) Word16
type AttrTransferTypeConstraint TypeInfoNPreallocsFieldInfo = (~)Word16
type AttrTransferType TypeInfoNPreallocsFieldInfo = Word16
type AttrGetType TypeInfoNPreallocsFieldInfo = Word16
type AttrLabel TypeInfoNPreallocsFieldInfo = "n_preallocs"
type AttrOrigin TypeInfoNPreallocsFieldInfo = TypeInfo
attrGet = getTypeInfoNPreallocs
attrSet = setTypeInfoNPreallocs
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.nPreallocs"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:nPreallocs"
})
typeInfo_nPreallocs :: AttrLabelProxy "nPreallocs"
typeInfo_nPreallocs = AttrLabelProxy
#endif
getTypeInfoInstanceInit :: MonadIO m => TypeInfo -> m (Maybe GObject.Callbacks.InstanceInitFunc)
getTypeInfoInstanceInit :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> m (Maybe InstanceInitFunc)
getTypeInfoInstanceInit TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
FunPtr C_InstanceInitFunc
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) :: IO (FunPtr GObject.Callbacks.C_InstanceInitFunc)
Maybe InstanceInitFunc
result <- forall a b. FunPtr a -> (FunPtr a -> IO b) -> IO (Maybe b)
SP.convertFunPtrIfNonNull FunPtr C_InstanceInitFunc
val forall a b. (a -> b) -> a -> b
$ \FunPtr C_InstanceInitFunc
val' -> do
let val'' :: InstanceInitFunc
val'' = forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
FunPtr C_InstanceInitFunc -> TypeInstance -> TypeClass -> m ()
GObject.Callbacks.dynamic_InstanceInitFunc FunPtr C_InstanceInitFunc
val'
forall (m :: * -> *) a. Monad m => a -> m a
return InstanceInitFunc
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe InstanceInitFunc
result
setTypeInfoInstanceInit :: MonadIO m => TypeInfo -> FunPtr GObject.Callbacks.C_InstanceInitFunc -> m ()
setTypeInfoInstanceInit :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> FunPtr C_InstanceInitFunc -> m ()
setTypeInfoInstanceInit TypeInfo
s FunPtr C_InstanceInitFunc
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (FunPtr C_InstanceInitFunc
val :: FunPtr GObject.Callbacks.C_InstanceInitFunc)
clearTypeInfoInstanceInit :: MonadIO m => TypeInfo -> m ()
clearTypeInfoInstanceInit :: forall (m :: * -> *). MonadIO m => TypeInfo -> m ()
clearTypeInfoInstanceInit TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
28) (forall a. FunPtr a
FP.nullFunPtr :: FunPtr GObject.Callbacks.C_InstanceInitFunc)
#if defined(ENABLE_OVERLOADING)
data TypeInfoInstanceInitFieldInfo
instance AttrInfo TypeInfoInstanceInitFieldInfo where
type AttrBaseTypeConstraint TypeInfoInstanceInitFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoInstanceInitFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeInfoInstanceInitFieldInfo = (~) (FunPtr GObject.Callbacks.C_InstanceInitFunc)
type AttrTransferTypeConstraint TypeInfoInstanceInitFieldInfo = (~)GObject.Callbacks.InstanceInitFunc
type AttrTransferType TypeInfoInstanceInitFieldInfo = (FunPtr GObject.Callbacks.C_InstanceInitFunc)
type AttrGetType TypeInfoInstanceInitFieldInfo = Maybe GObject.Callbacks.InstanceInitFunc
type AttrLabel TypeInfoInstanceInitFieldInfo = "instance_init"
type AttrOrigin TypeInfoInstanceInitFieldInfo = TypeInfo
attrGet = getTypeInfoInstanceInit
attrSet = setTypeInfoInstanceInit
attrConstruct = undefined
attrClear = clearTypeInfoInstanceInit
attrTransfer _ v = do
GObject.Callbacks.mk_InstanceInitFunc (GObject.Callbacks.wrap_InstanceInitFunc Nothing v)
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.instanceInit"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:instanceInit"
})
typeInfo_instanceInit :: AttrLabelProxy "instanceInit"
typeInfo_instanceInit = AttrLabelProxy
#endif
getTypeInfoValueTable :: MonadIO m => TypeInfo -> m (Maybe GObject.TypeValueTable.TypeValueTable)
getTypeInfoValueTable :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> m (Maybe TypeValueTable)
getTypeInfoValueTable TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
Ptr TypeValueTable
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) :: IO (Ptr GObject.TypeValueTable.TypeValueTable)
Maybe TypeValueTable
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr TypeValueTable
val forall a b. (a -> b) -> a -> b
$ \Ptr TypeValueTable
val' -> do
TypeValueTable
val'' <- (forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr TypeValueTable -> TypeValueTable
GObject.TypeValueTable.TypeValueTable) Ptr TypeValueTable
val'
forall (m :: * -> *) a. Monad m => a -> m a
return TypeValueTable
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe TypeValueTable
result
setTypeInfoValueTable :: MonadIO m => TypeInfo -> Ptr GObject.TypeValueTable.TypeValueTable -> m ()
setTypeInfoValueTable :: forall (m :: * -> *).
MonadIO m =>
TypeInfo -> Ptr TypeValueTable -> m ()
setTypeInfoValueTable TypeInfo
s Ptr TypeValueTable
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (Ptr TypeValueTable
val :: Ptr GObject.TypeValueTable.TypeValueTable)
clearTypeInfoValueTable :: MonadIO m => TypeInfo -> m ()
clearTypeInfoValueTable :: forall (m :: * -> *). MonadIO m => TypeInfo -> m ()
clearTypeInfoValueTable TypeInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr TypeInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr TypeInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr TypeInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
32) (forall a. Ptr a
FP.nullPtr :: Ptr GObject.TypeValueTable.TypeValueTable)
#if defined(ENABLE_OVERLOADING)
data TypeInfoValueTableFieldInfo
instance AttrInfo TypeInfoValueTableFieldInfo where
type AttrBaseTypeConstraint TypeInfoValueTableFieldInfo = (~) TypeInfo
type AttrAllowedOps TypeInfoValueTableFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint TypeInfoValueTableFieldInfo = (~) (Ptr GObject.TypeValueTable.TypeValueTable)
type AttrTransferTypeConstraint TypeInfoValueTableFieldInfo = (~)(Ptr GObject.TypeValueTable.TypeValueTable)
type AttrTransferType TypeInfoValueTableFieldInfo = (Ptr GObject.TypeValueTable.TypeValueTable)
type AttrGetType TypeInfoValueTableFieldInfo = Maybe GObject.TypeValueTable.TypeValueTable
type AttrLabel TypeInfoValueTableFieldInfo = "value_table"
type AttrOrigin TypeInfoValueTableFieldInfo = TypeInfo
attrGet = getTypeInfoValueTable
attrSet = setTypeInfoValueTable
attrConstruct = undefined
attrClear = clearTypeInfoValueTable
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.GObject.Structs.TypeInfo.valueTable"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gobject-2.0.28/docs/GI-GObject-Structs-TypeInfo.html#g:attr:valueTable"
})
typeInfo_valueTable :: AttrLabelProxy "valueTable"
typeInfo_valueTable = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList TypeInfo
type instance O.AttributeList TypeInfo = TypeInfoAttributeList
type TypeInfoAttributeList = ('[ '("classSize", TypeInfoClassSizeFieldInfo), '("baseInit", TypeInfoBaseInitFieldInfo), '("baseFinalize", TypeInfoBaseFinalizeFieldInfo), '("classInit", TypeInfoClassInitFieldInfo), '("classFinalize", TypeInfoClassFinalizeFieldInfo), '("classData", TypeInfoClassDataFieldInfo), '("instanceSize", TypeInfoInstanceSizeFieldInfo), '("nPreallocs", TypeInfoNPreallocsFieldInfo), '("instanceInit", TypeInfoInstanceInitFieldInfo), '("valueTable", TypeInfoValueTableFieldInfo)] :: [(Symbol, DK.Type)])
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveTypeInfoMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveTypeInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveTypeInfoMethod t TypeInfo, O.OverloadedMethod info TypeInfo p) => OL.IsLabel t (TypeInfo -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveTypeInfoMethod t TypeInfo, O.OverloadedMethod info TypeInfo p, R.HasField t TypeInfo p) => R.HasField t TypeInfo p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveTypeInfoMethod t TypeInfo, O.OverloadedMethodInfo info TypeInfo) => OL.IsLabel t (O.MethodProxy info TypeInfo) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif