#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GIRepository.Functions
(
argInfoGetClosure ,
argInfoGetDestroy ,
argInfoGetDirection ,
argInfoGetOwnershipTransfer ,
argInfoGetScope ,
argInfoGetType ,
argInfoIsCallerAllocates ,
argInfoIsOptional ,
argInfoIsReturnValue ,
argInfoIsSkip ,
argInfoLoadType ,
argInfoMayBeNull ,
callableInfoCanThrowGerror ,
callableInfoGetArg ,
callableInfoGetCallerOwns ,
callableInfoGetInstanceOwnershipTransfer,
callableInfoGetNArgs ,
callableInfoGetReturnAttribute ,
callableInfoGetReturnType ,
callableInfoInvoke ,
callableInfoIsMethod ,
callableInfoIterateReturnAttributes ,
callableInfoLoadArg ,
callableInfoLoadReturnType ,
callableInfoMayReturnNull ,
callableInfoSkipReturn ,
cclosureMarshalGeneric ,
constantInfoGetType ,
enumInfoGetErrorDomain ,
enumInfoGetMethod ,
enumInfoGetNMethods ,
enumInfoGetNValues ,
enumInfoGetStorageType ,
enumInfoGetValue ,
fieldInfoGetFlags ,
fieldInfoGetOffset ,
fieldInfoGetSize ,
fieldInfoGetType ,
functionInfoGetFlags ,
functionInfoGetProperty ,
functionInfoGetSymbol ,
functionInfoGetVfunc ,
getMajorVersion ,
getMicroVersion ,
getMinorVersion ,
infoNew ,
infoTypeToString ,
interfaceInfoFindMethod ,
interfaceInfoFindSignal ,
interfaceInfoFindVfunc ,
interfaceInfoGetConstant ,
interfaceInfoGetIfaceStruct ,
interfaceInfoGetMethod ,
interfaceInfoGetNConstants ,
interfaceInfoGetNMethods ,
interfaceInfoGetNPrerequisites ,
interfaceInfoGetNProperties ,
interfaceInfoGetNSignals ,
interfaceInfoGetNVfuncs ,
interfaceInfoGetPrerequisite ,
interfaceInfoGetProperty ,
interfaceInfoGetSignal ,
interfaceInfoGetVfunc ,
invokeErrorQuark ,
objectInfoFindMethod ,
objectInfoFindMethodUsingInterfaces ,
objectInfoFindSignal ,
objectInfoFindVfunc ,
objectInfoFindVfuncUsingInterfaces ,
objectInfoGetAbstract ,
objectInfoGetClassStruct ,
objectInfoGetConstant ,
objectInfoGetField ,
objectInfoGetFinal ,
objectInfoGetFundamental ,
objectInfoGetGetValueFunction ,
objectInfoGetInterface ,
objectInfoGetMethod ,
objectInfoGetNConstants ,
objectInfoGetNFields ,
objectInfoGetNInterfaces ,
objectInfoGetNMethods ,
objectInfoGetNProperties ,
objectInfoGetNSignals ,
objectInfoGetNVfuncs ,
objectInfoGetParent ,
objectInfoGetProperty ,
objectInfoGetRefFunction ,
objectInfoGetSetValueFunction ,
objectInfoGetSignal ,
objectInfoGetTypeInit ,
objectInfoGetTypeName ,
objectInfoGetUnrefFunction ,
objectInfoGetVfunc ,
propertyInfoGetFlags ,
propertyInfoGetGetter ,
propertyInfoGetOwnershipTransfer ,
propertyInfoGetSetter ,
propertyInfoGetType ,
registeredTypeInfoGetGType ,
registeredTypeInfoGetTypeInit ,
registeredTypeInfoGetTypeName ,
signalInfoGetClassClosure ,
signalInfoGetFlags ,
signalInfoTrueStopsEmit ,
structInfoFindField ,
structInfoFindMethod ,
structInfoGetAlignment ,
structInfoGetField ,
structInfoGetMethod ,
structInfoGetNFields ,
structInfoGetNMethods ,
structInfoGetSize ,
structInfoIsForeign ,
structInfoIsGtypeStruct ,
typeInfoArgumentFromHashPointer ,
typeInfoGetArrayFixedSize ,
typeInfoGetArrayLength ,
typeInfoGetArrayType ,
typeInfoGetInterface ,
typeInfoGetParamType ,
typeInfoGetStorageType ,
typeInfoGetTag ,
typeInfoHashPointerFromArgument ,
typeInfoIsPointer ,
typeInfoIsZeroTerminated ,
typeTagArgumentFromHashPointer ,
typeTagHashPointerFromArgument ,
typeTagToString ,
unionInfoFindMethod ,
unionInfoGetAlignment ,
unionInfoGetDiscriminator ,
unionInfoGetDiscriminatorOffset ,
unionInfoGetDiscriminatorType ,
unionInfoGetField ,
unionInfoGetMethod ,
unionInfoGetNFields ,
unionInfoGetNMethods ,
unionInfoGetSize ,
unionInfoIsDiscriminated ,
valueInfoGetValue ,
vfuncInfoGetAddress ,
vfuncInfoGetFlags ,
vfuncInfoGetInvoker ,
vfuncInfoGetOffset ,
vfuncInfoGetSignal ,
) 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.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 {-# SOURCE #-} qualified GI.GIRepository.Enums as GIRepository.Enums
import {-# SOURCE #-} qualified GI.GIRepository.Flags as GIRepository.Flags
import {-# SOURCE #-} qualified GI.GIRepository.Structs.AttributeIter as GIRepository.AttributeIter
import {-# SOURCE #-} qualified GI.GIRepository.Structs.BaseInfo as GIRepository.BaseInfo
import {-# SOURCE #-} qualified GI.GIRepository.Structs.Typelib as GIRepository.Typelib
import {-# SOURCE #-} qualified GI.GIRepository.Unions.Argument as GIRepository.Argument
import qualified GI.GObject.Flags as GObject.Flags
foreign import ccall "g_vfunc_info_get_signal" g_vfunc_info_get_signal ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
vfuncInfoGetSignal ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
vfuncInfoGetSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
vfuncInfoGetSignal BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_vfunc_info_get_signal Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"vfuncInfoGetSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_vfunc_info_get_offset" g_vfunc_info_get_offset ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
vfuncInfoGetOffset ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
vfuncInfoGetOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
vfuncInfoGetOffset BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_vfunc_info_get_offset Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_vfunc_info_get_invoker" g_vfunc_info_get_invoker ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
vfuncInfoGetInvoker ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
vfuncInfoGetInvoker :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
vfuncInfoGetInvoker BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_vfunc_info_get_invoker Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"vfuncInfoGetInvoker" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_vfunc_info_get_flags" g_vfunc_info_get_flags ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
vfuncInfoGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m [GIRepository.Flags.VFuncInfoFlags]
vfuncInfoGetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m [VFuncInfoFlags]
vfuncInfoGetFlags BaseInfo
info = IO [VFuncInfoFlags] -> m [VFuncInfoFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [VFuncInfoFlags] -> m [VFuncInfoFlags])
-> IO [VFuncInfoFlags] -> m [VFuncInfoFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_vfunc_info_get_flags Ptr BaseInfo
info'
let result' :: [VFuncInfoFlags]
result' = CUInt -> [VFuncInfoFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
[VFuncInfoFlags] -> IO [VFuncInfoFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [VFuncInfoFlags]
result'
foreign import ccall "g_vfunc_info_get_address" g_vfunc_info_get_address ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CGType ->
Ptr (Ptr GError) ->
IO (Ptr ())
vfuncInfoGetAddress ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> GType
-> m (Ptr ())
vfuncInfoGetAddress :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> GType -> m (Ptr ())
vfuncInfoGetAddress BaseInfo
info GType
implementorGtype = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
let implementorGtype' :: CGType
implementorGtype' = GType -> CGType
gtypeToCGType GType
implementorGtype
IO (Ptr ()) -> IO () -> IO (Ptr ())
forall a b. IO a -> IO b -> IO a
onException (do
Ptr ()
result <- (Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ())
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ()))
-> (Ptr (Ptr GError) -> IO (Ptr ())) -> IO (Ptr ())
forall a b. (a -> b) -> a -> b
$ Ptr BaseInfo -> CGType -> Ptr (Ptr GError) -> IO (Ptr ())
g_vfunc_info_get_address Ptr BaseInfo
info' CGType
implementorGtype'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
) (do
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
)
foreign import ccall "g_value_info_get_value" g_value_info_get_value ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int64
valueInfoGetValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int64
valueInfoGetValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int64
valueInfoGetValue BaseInfo
info = IO Int64 -> m Int64
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int64 -> m Int64) -> IO Int64 -> m Int64
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int64
result <- Ptr BaseInfo -> IO Int64
g_value_info_get_value Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int64 -> IO Int64
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int64
result
foreign import ccall "g_union_info_is_discriminated" g_union_info_is_discriminated ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
unionInfoIsDiscriminated ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
unionInfoIsDiscriminated :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
unionInfoIsDiscriminated BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_union_info_is_discriminated Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_union_info_get_size" g_union_info_get_size ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Word64
unionInfoGetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Word64
unionInfoGetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m CGType
unionInfoGetSize BaseInfo
info = IO CGType -> m CGType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CGType -> m CGType) -> IO CGType -> m CGType
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CGType
result <- Ptr BaseInfo -> IO CGType
g_union_info_get_size Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CGType -> IO CGType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CGType
result
foreign import ccall "g_union_info_get_n_methods" g_union_info_get_n_methods ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
unionInfoGetNMethods ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
unionInfoGetNMethods :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
unionInfoGetNMethods BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_union_info_get_n_methods Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_union_info_get_n_fields" g_union_info_get_n_fields ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
unionInfoGetNFields ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
unionInfoGetNFields :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
unionInfoGetNFields BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_union_info_get_n_fields Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_union_info_get_method" g_union_info_get_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
unionInfoGetMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
unionInfoGetMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
unionInfoGetMethod BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_union_info_get_method Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unionInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_union_info_get_field" g_union_info_get_field ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
unionInfoGetField ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
unionInfoGetField :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
unionInfoGetField BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_union_info_get_field Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unionInfoGetField" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_union_info_get_discriminator_type" g_union_info_get_discriminator_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
unionInfoGetDiscriminatorType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
unionInfoGetDiscriminatorType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
unionInfoGetDiscriminatorType BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_union_info_get_discriminator_type Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unionInfoGetDiscriminatorType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_union_info_get_discriminator_offset" g_union_info_get_discriminator_offset ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
unionInfoGetDiscriminatorOffset ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
unionInfoGetDiscriminatorOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
unionInfoGetDiscriminatorOffset BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_union_info_get_discriminator_offset Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_union_info_get_discriminator" g_union_info_get_discriminator ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
unionInfoGetDiscriminator ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
unionInfoGetDiscriminator :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
unionInfoGetDiscriminator BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_union_info_get_discriminator Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unionInfoGetDiscriminator" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_union_info_get_alignment" g_union_info_get_alignment ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Word64
unionInfoGetAlignment ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Word64
unionInfoGetAlignment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m CGType
unionInfoGetAlignment BaseInfo
info = IO CGType -> m CGType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CGType -> m CGType) -> IO CGType -> m CGType
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CGType
result <- Ptr BaseInfo -> IO CGType
g_union_info_get_alignment Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CGType -> IO CGType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CGType
result
foreign import ccall "g_union_info_find_method" g_union_info_find_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
unionInfoFindMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m GIRepository.BaseInfo.BaseInfo
unionInfoFindMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m BaseInfo
unionInfoFindMethod BaseInfo
info Text
name = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_union_info_find_method Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"unionInfoFindMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_type_tag_to_string" g_type_tag_to_string ::
CUInt ->
IO CString
typeTagToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.Enums.TypeTag
-> m T.Text
typeTagToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TypeTag -> m Text
typeTagToString TypeTag
type_ = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TypeTag -> Int) -> TypeTag -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeTag -> Int
forall a. Enum a => a -> Int
fromEnum) TypeTag
type_
CString
result <- CUInt -> IO CString
g_type_tag_to_string CUInt
type_'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"typeTagToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "gi_type_tag_hash_pointer_from_argument" gi_type_tag_hash_pointer_from_argument ::
CUInt ->
Ptr GIRepository.Argument.Argument ->
IO (Ptr ())
typeTagHashPointerFromArgument ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.Enums.TypeTag
-> GIRepository.Argument.Argument
-> m (Ptr ())
typeTagHashPointerFromArgument :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TypeTag -> Argument -> m (Ptr ())
typeTagHashPointerFromArgument TypeTag
storageType Argument
arg = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
let storageType' :: CUInt
storageType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TypeTag -> Int) -> TypeTag -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeTag -> Int
forall a. Enum a => a -> Int
fromEnum) TypeTag
storageType
Ptr Argument
arg' <- Argument -> IO (Ptr Argument)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Argument
arg
Ptr ()
result <- CUInt -> Ptr Argument -> IO (Ptr ())
gi_type_tag_hash_pointer_from_argument CUInt
storageType' Ptr Argument
arg'
Argument -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Argument
arg
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
foreign import ccall "gi_type_tag_argument_from_hash_pointer" gi_type_tag_argument_from_hash_pointer ::
CUInt ->
Ptr () ->
Ptr GIRepository.Argument.Argument ->
IO ()
typeTagArgumentFromHashPointer ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.Enums.TypeTag
-> Ptr ()
-> GIRepository.Argument.Argument
-> m ()
typeTagArgumentFromHashPointer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
TypeTag -> Ptr () -> Argument -> m ()
typeTagArgumentFromHashPointer TypeTag
storageType Ptr ()
hashPointer Argument
arg = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let storageType' :: CUInt
storageType' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (TypeTag -> Int) -> TypeTag -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TypeTag -> Int
forall a. Enum a => a -> Int
fromEnum) TypeTag
storageType
Ptr Argument
arg' <- Argument -> IO (Ptr Argument)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Argument
arg
CUInt -> Ptr () -> Ptr Argument -> IO ()
gi_type_tag_argument_from_hash_pointer CUInt
storageType' Ptr ()
hashPointer Ptr Argument
arg'
Argument -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Argument
arg
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "g_type_info_is_zero_terminated" g_type_info_is_zero_terminated ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
typeInfoIsZeroTerminated ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
typeInfoIsZeroTerminated :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
typeInfoIsZeroTerminated BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_type_info_is_zero_terminated Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_type_info_is_pointer" g_type_info_is_pointer ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
typeInfoIsPointer ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
typeInfoIsPointer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
typeInfoIsPointer BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_type_info_is_pointer Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_type_info_hash_pointer_from_argument" g_type_info_hash_pointer_from_argument ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Ptr GIRepository.Argument.Argument ->
IO (Ptr ())
typeInfoHashPointerFromArgument ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> GIRepository.Argument.Argument
-> m (Ptr ())
typeInfoHashPointerFromArgument :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Argument -> m (Ptr ())
typeInfoHashPointerFromArgument BaseInfo
info Argument
arg = IO (Ptr ()) -> m (Ptr ())
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr ()) -> m (Ptr ())) -> IO (Ptr ()) -> m (Ptr ())
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr Argument
arg' <- Argument -> IO (Ptr Argument)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Argument
arg
Ptr ()
result <- Ptr BaseInfo -> Ptr Argument -> IO (Ptr ())
g_type_info_hash_pointer_from_argument Ptr BaseInfo
info' Ptr Argument
arg'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Argument -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Argument
arg
Ptr () -> IO (Ptr ())
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
foreign import ccall "g_type_info_get_tag" g_type_info_get_tag ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
typeInfoGetTag ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.TypeTag
typeInfoGetTag :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m TypeTag
typeInfoGetTag BaseInfo
info = IO TypeTag -> m TypeTag
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeTag -> m TypeTag) -> IO TypeTag -> m TypeTag
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_type_info_get_tag Ptr BaseInfo
info'
let result' :: TypeTag
result' = (Int -> TypeTag
forall a. Enum a => Int -> a
toEnum (Int -> TypeTag) -> (CUInt -> Int) -> CUInt -> TypeTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
TypeTag -> IO TypeTag
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeTag
result'
foreign import ccall "g_type_info_get_storage_type" g_type_info_get_storage_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
typeInfoGetStorageType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.TypeTag
typeInfoGetStorageType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m TypeTag
typeInfoGetStorageType BaseInfo
info = IO TypeTag -> m TypeTag
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeTag -> m TypeTag) -> IO TypeTag -> m TypeTag
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_type_info_get_storage_type Ptr BaseInfo
info'
let result' :: TypeTag
result' = (Int -> TypeTag
forall a. Enum a => Int -> a
toEnum (Int -> TypeTag) -> (CUInt -> Int) -> CUInt -> TypeTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
TypeTag -> IO TypeTag
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeTag
result'
foreign import ccall "g_type_info_get_param_type" g_type_info_get_param_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
typeInfoGetParamType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
typeInfoGetParamType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
typeInfoGetParamType BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_type_info_get_param_type Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"typeInfoGetParamType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_type_info_get_interface" g_type_info_get_interface ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
typeInfoGetInterface ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
typeInfoGetInterface :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
typeInfoGetInterface BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_type_info_get_interface Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"typeInfoGetInterface" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_type_info_get_array_type" g_type_info_get_array_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
typeInfoGetArrayType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.ArrayType
typeInfoGetArrayType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m ArrayType
typeInfoGetArrayType BaseInfo
info = IO ArrayType -> m ArrayType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ArrayType -> m ArrayType) -> IO ArrayType -> m ArrayType
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_type_info_get_array_type Ptr BaseInfo
info'
let result' :: ArrayType
result' = (Int -> ArrayType
forall a. Enum a => Int -> a
toEnum (Int -> ArrayType) -> (CUInt -> Int) -> CUInt -> ArrayType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
ArrayType -> IO ArrayType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ArrayType
result'
foreign import ccall "g_type_info_get_array_length" g_type_info_get_array_length ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
typeInfoGetArrayLength ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
typeInfoGetArrayLength :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
typeInfoGetArrayLength BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_type_info_get_array_length Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_type_info_get_array_fixed_size" g_type_info_get_array_fixed_size ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
typeInfoGetArrayFixedSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
typeInfoGetArrayFixedSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
typeInfoGetArrayFixedSize BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_type_info_get_array_fixed_size Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_type_info_argument_from_hash_pointer" g_type_info_argument_from_hash_pointer ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Ptr () ->
Ptr GIRepository.Argument.Argument ->
IO ()
typeInfoArgumentFromHashPointer ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Ptr ()
-> GIRepository.Argument.Argument
-> m ()
typeInfoArgumentFromHashPointer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Ptr () -> Argument -> m ()
typeInfoArgumentFromHashPointer BaseInfo
info Ptr ()
hashPointer Argument
arg = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr Argument
arg' <- Argument -> IO (Ptr Argument)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Argument
arg
Ptr BaseInfo -> Ptr () -> Ptr Argument -> IO ()
g_type_info_argument_from_hash_pointer Ptr BaseInfo
info' Ptr ()
hashPointer Ptr Argument
arg'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Argument -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Argument
arg
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "g_struct_info_is_gtype_struct" g_struct_info_is_gtype_struct ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
structInfoIsGtypeStruct ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
structInfoIsGtypeStruct :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
structInfoIsGtypeStruct BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_struct_info_is_gtype_struct Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_struct_info_is_foreign" g_struct_info_is_foreign ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
structInfoIsForeign ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
structInfoIsForeign :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
structInfoIsForeign BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_struct_info_is_foreign Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_struct_info_get_size" g_struct_info_get_size ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Word64
structInfoGetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Word64
structInfoGetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m CGType
structInfoGetSize BaseInfo
info = IO CGType -> m CGType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CGType -> m CGType) -> IO CGType -> m CGType
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CGType
result <- Ptr BaseInfo -> IO CGType
g_struct_info_get_size Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CGType -> IO CGType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CGType
result
foreign import ccall "g_struct_info_get_n_methods" g_struct_info_get_n_methods ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
structInfoGetNMethods ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
structInfoGetNMethods :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
structInfoGetNMethods BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_struct_info_get_n_methods Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_struct_info_get_n_fields" g_struct_info_get_n_fields ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
structInfoGetNFields ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
structInfoGetNFields :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
structInfoGetNFields BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_struct_info_get_n_fields Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_struct_info_get_method" g_struct_info_get_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
structInfoGetMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
structInfoGetMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
structInfoGetMethod BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_struct_info_get_method Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_struct_info_get_field" g_struct_info_get_field ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
structInfoGetField ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
structInfoGetField :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
structInfoGetField BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_struct_info_get_field Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structInfoGetField" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_struct_info_get_alignment" g_struct_info_get_alignment ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Word64
structInfoGetAlignment ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Word64
structInfoGetAlignment :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m CGType
structInfoGetAlignment BaseInfo
info = IO CGType -> m CGType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CGType -> m CGType) -> IO CGType -> m CGType
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CGType
result <- Ptr BaseInfo -> IO CGType
g_struct_info_get_alignment Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CGType -> IO CGType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return CGType
result
foreign import ccall "g_struct_info_find_method" g_struct_info_find_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
structInfoFindMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m GIRepository.BaseInfo.BaseInfo
structInfoFindMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m BaseInfo
structInfoFindMethod BaseInfo
info Text
name = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_struct_info_find_method Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structInfoFindMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_struct_info_find_field" g_struct_info_find_field ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
structInfoFindField ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m GIRepository.BaseInfo.BaseInfo
structInfoFindField :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m BaseInfo
structInfoFindField BaseInfo
info Text
name = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_struct_info_find_field Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"structInfoFindField" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_signal_info_true_stops_emit" g_signal_info_true_stops_emit ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
signalInfoTrueStopsEmit ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
signalInfoTrueStopsEmit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
signalInfoTrueStopsEmit BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_signal_info_true_stops_emit Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_signal_info_get_flags" g_signal_info_get_flags ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
signalInfoGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m [GObject.Flags.SignalFlags]
signalInfoGetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m [SignalFlags]
signalInfoGetFlags BaseInfo
info = IO [SignalFlags] -> m [SignalFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [SignalFlags] -> m [SignalFlags])
-> IO [SignalFlags] -> m [SignalFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_signal_info_get_flags Ptr BaseInfo
info'
let result' :: [SignalFlags]
result' = CUInt -> [SignalFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
[SignalFlags] -> IO [SignalFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [SignalFlags]
result'
foreign import ccall "g_signal_info_get_class_closure" g_signal_info_get_class_closure ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
signalInfoGetClassClosure ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
signalInfoGetClassClosure :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
signalInfoGetClassClosure BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_signal_info_get_class_closure Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"signalInfoGetClassClosure" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_registered_type_info_get_type_name" g_registered_type_info_get_type_name ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
registeredTypeInfoGetTypeName ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m T.Text
registeredTypeInfoGetTypeName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Text
registeredTypeInfoGetTypeName BaseInfo
info = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_registered_type_info_get_type_name Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"registeredTypeInfoGetTypeName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "g_registered_type_info_get_type_init" g_registered_type_info_get_type_init ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
registeredTypeInfoGetTypeInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m T.Text
registeredTypeInfoGetTypeInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Text
registeredTypeInfoGetTypeInit BaseInfo
info = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_registered_type_info_get_type_init Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"registeredTypeInfoGetTypeInit" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "g_registered_type_info_get_g_type" g_registered_type_info_get_g_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CGType
registeredTypeInfoGetGType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GType
registeredTypeInfoGetGType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m GType
registeredTypeInfoGetGType BaseInfo
info = IO GType -> m GType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GType -> m GType) -> IO GType -> m GType
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CGType
result <- Ptr BaseInfo -> IO CGType
g_registered_type_info_get_g_type Ptr BaseInfo
info'
let result' :: GType
result' = CGType -> GType
GType CGType
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
GType -> IO GType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return GType
result'
foreign import ccall "g_property_info_get_type" g_property_info_get_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
propertyInfoGetType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
propertyInfoGetType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
propertyInfoGetType BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_property_info_get_type Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"propertyInfoGetType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_property_info_get_setter" g_property_info_get_setter ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
propertyInfoGetSetter ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (Maybe GIRepository.BaseInfo.BaseInfo)
propertyInfoGetSetter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m (Maybe BaseInfo)
propertyInfoGetSetter BaseInfo
info = IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo) -> m (Maybe BaseInfo))
-> IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_property_info_get_setter Ptr BaseInfo
info'
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Maybe BaseInfo -> IO (Maybe BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInfo
maybeResult
foreign import ccall "g_property_info_get_ownership_transfer" g_property_info_get_ownership_transfer ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
propertyInfoGetOwnershipTransfer ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.Transfer
propertyInfoGetOwnershipTransfer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Transfer
propertyInfoGetOwnershipTransfer BaseInfo
info = IO Transfer -> m Transfer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transfer -> m Transfer) -> IO Transfer -> m Transfer
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_property_info_get_ownership_transfer Ptr BaseInfo
info'
let result' :: Transfer
result' = (Int -> Transfer
forall a. Enum a => Int -> a
toEnum (Int -> Transfer) -> (CUInt -> Int) -> CUInt -> Transfer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Transfer -> IO Transfer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Transfer
result'
foreign import ccall "g_property_info_get_getter" g_property_info_get_getter ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
propertyInfoGetGetter ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (Maybe GIRepository.BaseInfo.BaseInfo)
propertyInfoGetGetter :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m (Maybe BaseInfo)
propertyInfoGetGetter BaseInfo
info = IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo) -> m (Maybe BaseInfo))
-> IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_property_info_get_getter Ptr BaseInfo
info'
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Maybe BaseInfo -> IO (Maybe BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInfo
maybeResult
foreign import ccall "g_property_info_get_flags" g_property_info_get_flags ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
propertyInfoGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m [GObject.Flags.ParamFlags]
propertyInfoGetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m [ParamFlags]
propertyInfoGetFlags BaseInfo
info = IO [ParamFlags] -> m [ParamFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [ParamFlags] -> m [ParamFlags])
-> IO [ParamFlags] -> m [ParamFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_property_info_get_flags Ptr BaseInfo
info'
let result' :: [ParamFlags]
result' = CUInt -> [ParamFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
[ParamFlags] -> IO [ParamFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [ParamFlags]
result'
foreign import ccall "g_object_info_get_vfunc" g_object_info_get_vfunc ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetVfunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
objectInfoGetVfunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
objectInfoGetVfunc BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_object_info_get_vfunc Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_object_info_get_unref_function" g_object_info_get_unref_function ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
objectInfoGetUnrefFunction ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (Maybe T.Text)
objectInfoGetUnrefFunction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m (Maybe Text)
objectInfoGetUnrefFunction BaseInfo
info = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_object_info_get_unref_function Ptr BaseInfo
info'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "g_object_info_get_type_name" g_object_info_get_type_name ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
objectInfoGetTypeName ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m T.Text
objectInfoGetTypeName :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Text
objectInfoGetTypeName BaseInfo
info = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_object_info_get_type_name Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetTypeName" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "g_object_info_get_type_init" g_object_info_get_type_init ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
objectInfoGetTypeInit ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m T.Text
objectInfoGetTypeInit :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Text
objectInfoGetTypeInit BaseInfo
info = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_object_info_get_type_init Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetTypeInit" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "g_object_info_get_signal" g_object_info_get_signal ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetSignal ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
objectInfoGetSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
objectInfoGetSignal BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_object_info_get_signal Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_object_info_get_set_value_function" g_object_info_get_set_value_function ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
objectInfoGetSetValueFunction ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (Maybe T.Text)
objectInfoGetSetValueFunction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m (Maybe Text)
objectInfoGetSetValueFunction BaseInfo
info = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_object_info_get_set_value_function Ptr BaseInfo
info'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "g_object_info_get_ref_function" g_object_info_get_ref_function ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
objectInfoGetRefFunction ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (Maybe T.Text)
objectInfoGetRefFunction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m (Maybe Text)
objectInfoGetRefFunction BaseInfo
info = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_object_info_get_ref_function Ptr BaseInfo
info'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "g_object_info_get_property" g_object_info_get_property ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
objectInfoGetProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
objectInfoGetProperty BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_object_info_get_property Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetProperty" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_object_info_get_parent" g_object_info_get_parent ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetParent ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (Maybe GIRepository.BaseInfo.BaseInfo)
objectInfoGetParent :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m (Maybe BaseInfo)
objectInfoGetParent BaseInfo
info = IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo) -> m (Maybe BaseInfo))
-> IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_object_info_get_parent Ptr BaseInfo
info'
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Maybe BaseInfo -> IO (Maybe BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInfo
maybeResult
foreign import ccall "g_object_info_get_n_vfuncs" g_object_info_get_n_vfuncs ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
objectInfoGetNVfuncs ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
objectInfoGetNVfuncs :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
objectInfoGetNVfuncs BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_object_info_get_n_vfuncs Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_object_info_get_n_signals" g_object_info_get_n_signals ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
objectInfoGetNSignals ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
objectInfoGetNSignals :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
objectInfoGetNSignals BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_object_info_get_n_signals Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_object_info_get_n_properties" g_object_info_get_n_properties ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
objectInfoGetNProperties ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
objectInfoGetNProperties :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
objectInfoGetNProperties BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_object_info_get_n_properties Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_object_info_get_n_methods" g_object_info_get_n_methods ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
objectInfoGetNMethods ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
objectInfoGetNMethods :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
objectInfoGetNMethods BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_object_info_get_n_methods Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_object_info_get_n_interfaces" g_object_info_get_n_interfaces ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
objectInfoGetNInterfaces ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
objectInfoGetNInterfaces :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
objectInfoGetNInterfaces BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_object_info_get_n_interfaces Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_object_info_get_n_fields" g_object_info_get_n_fields ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
objectInfoGetNFields ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
objectInfoGetNFields :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
objectInfoGetNFields BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_object_info_get_n_fields Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_object_info_get_n_constants" g_object_info_get_n_constants ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
objectInfoGetNConstants ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
objectInfoGetNConstants :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
objectInfoGetNConstants BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_object_info_get_n_constants Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_object_info_get_method" g_object_info_get_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
objectInfoGetMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
objectInfoGetMethod BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_object_info_get_method Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_object_info_get_interface" g_object_info_get_interface ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetInterface ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
objectInfoGetInterface :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
objectInfoGetInterface BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_object_info_get_interface Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetInterface" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_object_info_get_get_value_function" g_object_info_get_get_value_function ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
objectInfoGetGetValueFunction ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (Maybe T.Text)
objectInfoGetGetValueFunction :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m (Maybe Text)
objectInfoGetGetValueFunction BaseInfo
info = IO (Maybe Text) -> m (Maybe Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_object_info_get_get_value_function Ptr BaseInfo
info'
Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \CString
result' -> do
Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Maybe Text -> IO (Maybe Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult
foreign import ccall "g_object_info_get_fundamental" g_object_info_get_fundamental ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
objectInfoGetFundamental ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
objectInfoGetFundamental :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
objectInfoGetFundamental BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_object_info_get_fundamental Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_object_info_get_final" g_object_info_get_final ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
objectInfoGetFinal ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
objectInfoGetFinal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
objectInfoGetFinal BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_object_info_get_final Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_object_info_get_field" g_object_info_get_field ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetField ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
objectInfoGetField :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
objectInfoGetField BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_object_info_get_field Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetField" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_object_info_get_constant" g_object_info_get_constant ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetConstant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
objectInfoGetConstant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
objectInfoGetConstant BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_object_info_get_constant Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"objectInfoGetConstant" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_object_info_get_class_struct" g_object_info_get_class_struct ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoGetClassStruct ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (Maybe GIRepository.BaseInfo.BaseInfo)
objectInfoGetClassStruct :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m (Maybe BaseInfo)
objectInfoGetClassStruct BaseInfo
info = IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo) -> m (Maybe BaseInfo))
-> IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_object_info_get_class_struct Ptr BaseInfo
info'
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Maybe BaseInfo -> IO (Maybe BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInfo
maybeResult
foreign import ccall "g_object_info_get_abstract" g_object_info_get_abstract ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
objectInfoGetAbstract ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
objectInfoGetAbstract :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
objectInfoGetAbstract BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_object_info_get_abstract Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_object_info_find_vfunc_using_interfaces" g_object_info_find_vfunc_using_interfaces ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
Ptr (Ptr GIRepository.BaseInfo.BaseInfo) ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoFindVfuncUsingInterfaces ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m ((Maybe GIRepository.BaseInfo.BaseInfo, GIRepository.BaseInfo.BaseInfo))
objectInfoFindVfuncUsingInterfaces :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m (Maybe BaseInfo, BaseInfo)
objectInfoFindVfuncUsingInterfaces BaseInfo
info Text
name = IO (Maybe BaseInfo, BaseInfo) -> m (Maybe BaseInfo, BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo, BaseInfo) -> m (Maybe BaseInfo, BaseInfo))
-> IO (Maybe BaseInfo, BaseInfo) -> m (Maybe BaseInfo, BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr (Ptr BaseInfo)
implementor <- IO (Ptr (Ptr BaseInfo))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GIRepository.BaseInfo.BaseInfo))
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> Ptr (Ptr BaseInfo) -> IO (Ptr BaseInfo)
g_object_info_find_vfunc_using_interfaces Ptr BaseInfo
info' CString
name' Ptr (Ptr BaseInfo)
implementor
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
Ptr BaseInfo
implementor' <- Ptr (Ptr BaseInfo) -> IO (Ptr BaseInfo)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr BaseInfo)
implementor
BaseInfo
implementor'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
implementor'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Ptr (Ptr BaseInfo) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr BaseInfo)
implementor
(Maybe BaseInfo, BaseInfo) -> IO (Maybe BaseInfo, BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe BaseInfo
maybeResult, BaseInfo
implementor'')
foreign import ccall "g_object_info_find_vfunc" g_object_info_find_vfunc ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoFindVfunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m (Maybe GIRepository.BaseInfo.BaseInfo)
objectInfoFindVfunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m (Maybe BaseInfo)
objectInfoFindVfunc BaseInfo
info Text
name = IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo) -> m (Maybe BaseInfo))
-> IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_object_info_find_vfunc Ptr BaseInfo
info' CString
name'
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe BaseInfo -> IO (Maybe BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInfo
maybeResult
foreign import ccall "g_object_info_find_signal" g_object_info_find_signal ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoFindSignal ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m (Maybe GIRepository.BaseInfo.BaseInfo)
objectInfoFindSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m (Maybe BaseInfo)
objectInfoFindSignal BaseInfo
info Text
name = IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo) -> m (Maybe BaseInfo))
-> IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_object_info_find_signal Ptr BaseInfo
info' CString
name'
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe BaseInfo -> IO (Maybe BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInfo
maybeResult
foreign import ccall "g_object_info_find_method_using_interfaces" g_object_info_find_method_using_interfaces ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
Ptr (Ptr GIRepository.BaseInfo.BaseInfo) ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoFindMethodUsingInterfaces ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m ((Maybe GIRepository.BaseInfo.BaseInfo, GIRepository.BaseInfo.BaseInfo))
objectInfoFindMethodUsingInterfaces :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m (Maybe BaseInfo, BaseInfo)
objectInfoFindMethodUsingInterfaces BaseInfo
info Text
name = IO (Maybe BaseInfo, BaseInfo) -> m (Maybe BaseInfo, BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo, BaseInfo) -> m (Maybe BaseInfo, BaseInfo))
-> IO (Maybe BaseInfo, BaseInfo) -> m (Maybe BaseInfo, BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr (Ptr BaseInfo)
implementor <- IO (Ptr (Ptr BaseInfo))
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr (Ptr GIRepository.BaseInfo.BaseInfo))
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> Ptr (Ptr BaseInfo) -> IO (Ptr BaseInfo)
g_object_info_find_method_using_interfaces Ptr BaseInfo
info' CString
name' Ptr (Ptr BaseInfo)
implementor
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
Ptr BaseInfo
implementor' <- Ptr (Ptr BaseInfo) -> IO (Ptr BaseInfo)
forall a. Storable a => Ptr a -> IO a
peek Ptr (Ptr BaseInfo)
implementor
BaseInfo
implementor'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
implementor'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Ptr (Ptr BaseInfo) -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr (Ptr BaseInfo)
implementor
(Maybe BaseInfo, BaseInfo) -> IO (Maybe BaseInfo, BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe BaseInfo
maybeResult, BaseInfo
implementor'')
foreign import ccall "g_object_info_find_method" g_object_info_find_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
objectInfoFindMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m (Maybe GIRepository.BaseInfo.BaseInfo)
objectInfoFindMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m (Maybe BaseInfo)
objectInfoFindMethod BaseInfo
info Text
name = IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe BaseInfo) -> m (Maybe BaseInfo))
-> IO (Maybe BaseInfo) -> m (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_object_info_find_method Ptr BaseInfo
info' CString
name'
Maybe BaseInfo
maybeResult <- Ptr BaseInfo
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr BaseInfo
result ((Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo))
-> (Ptr BaseInfo -> IO BaseInfo) -> IO (Maybe BaseInfo)
forall a b. (a -> b) -> a -> b
$ \Ptr BaseInfo
result' -> do
BaseInfo
result'' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result''
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Maybe BaseInfo -> IO (Maybe BaseInfo)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe BaseInfo
maybeResult
foreign import ccall "g_invoke_error_quark" g_invoke_error_quark ::
IO Word32
invokeErrorQuark ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
invokeErrorQuark :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
invokeErrorQuark = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
g_invoke_error_quark
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "g_interface_info_get_vfunc" g_interface_info_get_vfunc ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoGetVfunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoGetVfunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetVfunc BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_interface_info_get_vfunc Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoGetVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_get_signal" g_interface_info_get_signal ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoGetSignal ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoGetSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetSignal BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_interface_info_get_signal Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoGetSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_get_property" g_interface_info_get_property ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoGetProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoGetProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetProperty BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_interface_info_get_property Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoGetProperty" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_get_prerequisite" g_interface_info_get_prerequisite ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoGetPrerequisite ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoGetPrerequisite :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetPrerequisite BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_interface_info_get_prerequisite Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoGetPrerequisite" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_get_n_vfuncs" g_interface_info_get_n_vfuncs ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
interfaceInfoGetNVfuncs ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
interfaceInfoGetNVfuncs :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
interfaceInfoGetNVfuncs BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_interface_info_get_n_vfuncs Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_interface_info_get_n_signals" g_interface_info_get_n_signals ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
interfaceInfoGetNSignals ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
interfaceInfoGetNSignals :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
interfaceInfoGetNSignals BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_interface_info_get_n_signals Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_interface_info_get_n_properties" g_interface_info_get_n_properties ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
interfaceInfoGetNProperties ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
interfaceInfoGetNProperties :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
interfaceInfoGetNProperties BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_interface_info_get_n_properties Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_interface_info_get_n_prerequisites" g_interface_info_get_n_prerequisites ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
interfaceInfoGetNPrerequisites ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
interfaceInfoGetNPrerequisites :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
interfaceInfoGetNPrerequisites BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_interface_info_get_n_prerequisites Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_interface_info_get_n_methods" g_interface_info_get_n_methods ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
interfaceInfoGetNMethods ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
interfaceInfoGetNMethods :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
interfaceInfoGetNMethods BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_interface_info_get_n_methods Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_interface_info_get_n_constants" g_interface_info_get_n_constants ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
interfaceInfoGetNConstants ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
interfaceInfoGetNConstants :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
interfaceInfoGetNConstants BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_interface_info_get_n_constants Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_interface_info_get_method" g_interface_info_get_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoGetMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoGetMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetMethod BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_interface_info_get_method Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_get_iface_struct" g_interface_info_get_iface_struct ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoGetIfaceStruct ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoGetIfaceStruct :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
interfaceInfoGetIfaceStruct BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_interface_info_get_iface_struct Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoGetIfaceStruct" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_get_constant" g_interface_info_get_constant ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoGetConstant ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoGetConstant :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetConstant BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_interface_info_get_constant Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoGetConstant" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_find_vfunc" g_interface_info_find_vfunc ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoFindVfunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoFindVfunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m BaseInfo
interfaceInfoFindVfunc BaseInfo
info Text
name = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_interface_info_find_vfunc Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoFindVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_find_signal" g_interface_info_find_signal ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoFindSignal ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoFindSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m BaseInfo
interfaceInfoFindSignal BaseInfo
info Text
name = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_interface_info_find_signal Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoFindSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_interface_info_find_method" g_interface_info_find_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
interfaceInfoFindMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m GIRepository.BaseInfo.BaseInfo
interfaceInfoFindMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m BaseInfo
interfaceInfoFindMethod BaseInfo
info Text
name = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr BaseInfo
result <- Ptr BaseInfo -> CString -> IO (Ptr BaseInfo)
g_interface_info_find_method Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"interfaceInfoFindMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_info_type_to_string" g_info_type_to_string ::
CUInt ->
IO CString
infoTypeToString ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.Enums.InfoType
-> m T.Text
infoTypeToString :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
InfoType -> m Text
infoTypeToString InfoType
type_ = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (InfoType -> Int) -> InfoType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InfoType -> Int
forall a. Enum a => a -> Int
fromEnum) InfoType
type_
CString
result <- CUInt -> IO CString
g_info_type_to_string CUInt
type_'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"infoTypeToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "g_info_new" g_info_new ::
CUInt ->
Ptr GIRepository.BaseInfo.BaseInfo ->
Ptr GIRepository.Typelib.Typelib ->
Word32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
infoNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.Enums.InfoType
-> GIRepository.BaseInfo.BaseInfo
-> GIRepository.Typelib.Typelib
-> Word32
-> m GIRepository.BaseInfo.BaseInfo
infoNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
InfoType -> BaseInfo -> Typelib -> Word32 -> m BaseInfo
infoNew InfoType
type_ BaseInfo
container Typelib
typelib Word32
offset = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
let type_' :: CUInt
type_' = (Int -> CUInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CUInt) -> (InfoType -> Int) -> InfoType -> CUInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InfoType -> Int
forall a. Enum a => a -> Int
fromEnum) InfoType
type_
Ptr BaseInfo
container' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
container
Ptr Typelib
typelib' <- Typelib -> IO (Ptr Typelib)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Typelib
typelib
Ptr BaseInfo
result <- CUInt -> Ptr BaseInfo -> Ptr Typelib -> Word32 -> IO (Ptr BaseInfo)
g_info_new CUInt
type_' Ptr BaseInfo
container' Ptr Typelib
typelib' Word32
offset
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"infoNew" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
container
Typelib -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Typelib
typelib
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "gi_get_minor_version" gi_get_minor_version ::
IO Word32
getMinorVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
getMinorVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
getMinorVersion = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
gi_get_minor_version
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "gi_get_micro_version" gi_get_micro_version ::
IO Word32
getMicroVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
getMicroVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
getMicroVersion = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
gi_get_micro_version
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "gi_get_major_version" gi_get_major_version ::
IO Word32
getMajorVersion ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
getMajorVersion :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Word32
getMajorVersion = IO Word32 -> m Word32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word32 -> m Word32) -> IO Word32 -> m Word32
forall a b. (a -> b) -> a -> b
$ do
Word32
result <- IO Word32
gi_get_major_version
Word32 -> IO Word32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Word32
result
foreign import ccall "g_function_info_get_vfunc" g_function_info_get_vfunc ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
functionInfoGetVfunc ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
functionInfoGetVfunc :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
functionInfoGetVfunc BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_function_info_get_vfunc Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"functionInfoGetVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_function_info_get_symbol" g_function_info_get_symbol ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
functionInfoGetSymbol ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m T.Text
functionInfoGetSymbol :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Text
functionInfoGetSymbol BaseInfo
info = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_function_info_get_symbol Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"functionInfoGetSymbol" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "g_function_info_get_property" g_function_info_get_property ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
functionInfoGetProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
functionInfoGetProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
functionInfoGetProperty BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_function_info_get_property Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"functionInfoGetProperty" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_function_info_get_flags" g_function_info_get_flags ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
functionInfoGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m [GIRepository.Flags.FunctionInfoFlags]
functionInfoGetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m [FunctionInfoFlags]
functionInfoGetFlags BaseInfo
info = IO [FunctionInfoFlags] -> m [FunctionInfoFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [FunctionInfoFlags] -> m [FunctionInfoFlags])
-> IO [FunctionInfoFlags] -> m [FunctionInfoFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_function_info_get_flags Ptr BaseInfo
info'
let result' :: [FunctionInfoFlags]
result' = CUInt -> [FunctionInfoFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
[FunctionInfoFlags] -> IO [FunctionInfoFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [FunctionInfoFlags]
result'
foreign import ccall "g_field_info_get_type" g_field_info_get_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
fieldInfoGetType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
fieldInfoGetType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
fieldInfoGetType BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_field_info_get_type Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"fieldInfoGetType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_field_info_get_size" g_field_info_get_size ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
fieldInfoGetSize ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
fieldInfoGetSize :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
fieldInfoGetSize BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_field_info_get_size Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_field_info_get_offset" g_field_info_get_offset ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
fieldInfoGetOffset ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
fieldInfoGetOffset :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
fieldInfoGetOffset BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_field_info_get_offset Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_field_info_get_flags" g_field_info_get_flags ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
fieldInfoGetFlags ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m [GIRepository.Flags.FieldInfoFlags]
fieldInfoGetFlags :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m [FieldInfoFlags]
fieldInfoGetFlags BaseInfo
info = IO [FieldInfoFlags] -> m [FieldInfoFlags]
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO [FieldInfoFlags] -> m [FieldInfoFlags])
-> IO [FieldInfoFlags] -> m [FieldInfoFlags]
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_field_info_get_flags Ptr BaseInfo
info'
let result' :: [FieldInfoFlags]
result' = CUInt -> [FieldInfoFlags]
forall a b. (Storable a, Integral a, Bits a, IsGFlag b) => a -> [b]
wordToGFlags CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
[FieldInfoFlags] -> IO [FieldInfoFlags]
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return [FieldInfoFlags]
result'
foreign import ccall "g_enum_info_get_value" g_enum_info_get_value ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
enumInfoGetValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
enumInfoGetValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
enumInfoGetValue BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_enum_info_get_value Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"enumInfoGetValue" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_enum_info_get_storage_type" g_enum_info_get_storage_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
enumInfoGetStorageType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.TypeTag
enumInfoGetStorageType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m TypeTag
enumInfoGetStorageType BaseInfo
info = IO TypeTag -> m TypeTag
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO TypeTag -> m TypeTag) -> IO TypeTag -> m TypeTag
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_enum_info_get_storage_type Ptr BaseInfo
info'
let result' :: TypeTag
result' = (Int -> TypeTag
forall a. Enum a => Int -> a
toEnum (Int -> TypeTag) -> (CUInt -> Int) -> CUInt -> TypeTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
TypeTag -> IO TypeTag
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return TypeTag
result'
foreign import ccall "g_enum_info_get_n_values" g_enum_info_get_n_values ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
enumInfoGetNValues ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
enumInfoGetNValues :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
enumInfoGetNValues BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_enum_info_get_n_values Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_enum_info_get_n_methods" g_enum_info_get_n_methods ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
enumInfoGetNMethods ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
enumInfoGetNMethods :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
enumInfoGetNMethods BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_enum_info_get_n_methods Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_enum_info_get_method" g_enum_info_get_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
enumInfoGetMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
enumInfoGetMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
enumInfoGetMethod BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_enum_info_get_method Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"enumInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_enum_info_get_error_domain" g_enum_info_get_error_domain ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CString
enumInfoGetErrorDomain ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m T.Text
enumInfoGetErrorDomain :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Text
enumInfoGetErrorDomain BaseInfo
info = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
result <- Ptr BaseInfo -> IO CString
g_enum_info_get_error_domain Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"enumInfoGetErrorDomain" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "g_constant_info_get_type" g_constant_info_get_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
constantInfoGetType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
constantInfoGetType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
constantInfoGetType BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_constant_info_get_type Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"constantInfoGetType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "gi_cclosure_marshal_generic" gi_cclosure_marshal_generic ::
Ptr (GClosure ()) ->
Ptr GValue ->
Word32 ->
Ptr GValue ->
Ptr () ->
Ptr () ->
IO ()
cclosureMarshalGeneric ::
(B.CallStack.HasCallStack, MonadIO m) =>
GClosure a
-> GValue
-> Word32
-> GValue
-> Ptr ()
-> Ptr ()
-> m ()
cclosureMarshalGeneric :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m) =>
GClosure a
-> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
cclosureMarshalGeneric GClosure a
closure GValue
returnGvalue Word32
nParamValues GValue
paramValues Ptr ()
invocationHint Ptr ()
marshalData = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
Ptr (GClosure ())
closure' <- GClosure a -> IO (Ptr (GClosure ()))
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr GClosure a
closure
Ptr GValue
returnGvalue' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
returnGvalue
Ptr GValue
paramValues' <- GValue -> IO (Ptr GValue)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr GValue
paramValues
Ptr (GClosure ())
-> Ptr GValue -> Word32 -> Ptr GValue -> Ptr () -> Ptr () -> IO ()
gi_cclosure_marshal_generic Ptr (GClosure ())
closure' Ptr GValue
returnGvalue' Word32
nParamValues Ptr GValue
paramValues' Ptr ()
invocationHint Ptr ()
marshalData
GClosure a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GClosure a
closure
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
returnGvalue
GValue -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr GValue
paramValues
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
foreign import ccall "g_callable_info_skip_return" g_callable_info_skip_return ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
callableInfoSkipReturn ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
callableInfoSkipReturn :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
callableInfoSkipReturn BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_callable_info_skip_return Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_callable_info_may_return_null" g_callable_info_may_return_null ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
callableInfoMayReturnNull ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
callableInfoMayReturnNull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
callableInfoMayReturnNull BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_callable_info_may_return_null Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_callable_info_load_return_type" g_callable_info_load_return_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Ptr GIRepository.BaseInfo.BaseInfo ->
IO ()
callableInfoLoadReturnType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (GIRepository.BaseInfo.BaseInfo)
callableInfoLoadReturnType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
callableInfoLoadReturnType BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
type_ <- Int -> IO (Ptr BaseInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo)
Ptr BaseInfo -> Ptr BaseInfo -> IO ()
g_callable_info_load_return_type Ptr BaseInfo
info' Ptr BaseInfo
type_
BaseInfo
type_' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
type_
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
type_'
foreign import ccall "g_callable_info_load_arg" g_callable_info_load_arg ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
Ptr GIRepository.BaseInfo.BaseInfo ->
IO ()
callableInfoLoadArg ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m (GIRepository.BaseInfo.BaseInfo)
callableInfoLoadArg :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
callableInfoLoadArg BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
arg <- Int -> IO (Ptr BaseInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo)
Ptr BaseInfo -> Int32 -> Ptr BaseInfo -> IO ()
g_callable_info_load_arg Ptr BaseInfo
info' Int32
n Ptr BaseInfo
arg
BaseInfo
arg' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
arg
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
arg'
foreign import ccall "g_callable_info_iterate_return_attributes" g_callable_info_iterate_return_attributes ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Ptr GIRepository.AttributeIter.AttributeIter ->
Ptr CString ->
Ptr CString ->
IO CInt
callableInfoIterateReturnAttributes ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> GIRepository.AttributeIter.AttributeIter
-> m ((Bool, T.Text, T.Text))
callableInfoIterateReturnAttributes :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> AttributeIter -> m (Bool, Text, Text)
callableInfoIterateReturnAttributes BaseInfo
info AttributeIter
iterator = IO (Bool, Text, Text) -> m (Bool, Text, Text)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Bool, Text, Text) -> m (Bool, Text, Text))
-> IO (Bool, Text, Text) -> m (Bool, Text, Text)
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr AttributeIter
iterator' <- AttributeIter -> IO (Ptr AttributeIter)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr AttributeIter
iterator
Ptr CString
name <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
Ptr CString
value <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- Ptr BaseInfo
-> Ptr AttributeIter -> Ptr CString -> Ptr CString -> IO CInt
g_callable_info_iterate_return_attributes Ptr BaseInfo
info' Ptr AttributeIter
iterator' Ptr CString
name Ptr CString
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
name' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
name
Text
name'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name'
CString
value' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
value
Text
value'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
AttributeIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AttributeIter
iterator
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
name
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
value
(Bool, Text, Text) -> IO (Bool, Text, Text)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
name'', Text
value'')
foreign import ccall "g_callable_info_is_method" g_callable_info_is_method ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
callableInfoIsMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
callableInfoIsMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
callableInfoIsMethod BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_callable_info_is_method Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_callable_info_invoke" g_callable_info_invoke ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Ptr () ->
Ptr GIRepository.Argument.Argument ->
Int32 ->
Ptr GIRepository.Argument.Argument ->
Int32 ->
Ptr GIRepository.Argument.Argument ->
CInt ->
CInt ->
Ptr (Ptr GError) ->
IO CInt
callableInfoInvoke ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Ptr ()
-> [GIRepository.Argument.Argument]
-> [GIRepository.Argument.Argument]
-> GIRepository.Argument.Argument
-> Bool
-> Bool
-> m ()
callableInfoInvoke :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo
-> Ptr ()
-> [Argument]
-> [Argument]
-> Argument
-> Bool
-> Bool
-> m ()
callableInfoInvoke BaseInfo
info Ptr ()
function [Argument]
inArgs [Argument]
outArgs Argument
returnValue Bool
isMethod Bool
throws = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
let nOutArgs :: Int32
nOutArgs = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Argument] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Argument]
outArgs
let nInArgs :: Int32
nInArgs = Int -> Int32
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int32) -> Int -> Int32
forall a b. (a -> b) -> a -> b
$ [Argument] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
P.length [Argument]
inArgs
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
[Ptr Argument]
inArgs' <- (Argument -> IO (Ptr Argument)) -> [Argument] -> IO [Ptr Argument]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Argument -> IO (Ptr Argument)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [Argument]
inArgs
Ptr Argument
inArgs'' <- Int -> [Ptr Argument] -> IO (Ptr Argument)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray Int
8 [Ptr Argument]
inArgs'
[Ptr Argument]
outArgs' <- (Argument -> IO (Ptr Argument)) -> [Argument] -> IO [Ptr Argument]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM Argument -> IO (Ptr Argument)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr [Argument]
outArgs
Ptr Argument
outArgs'' <- Int -> [Ptr Argument] -> IO (Ptr Argument)
forall a. Int -> [Ptr a] -> IO (Ptr a)
packBlockArray Int
8 [Ptr Argument]
outArgs'
Ptr Argument
returnValue' <- Argument -> IO (Ptr Argument)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr Argument
returnValue
let isMethod' :: CInt
isMethod' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
isMethod
let throws' :: CInt
throws' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
throws
IO () -> IO () -> IO ()
forall a b. IO a -> IO b -> IO a
onException (do
CInt
_ <- (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a. (Ptr (Ptr GError) -> IO a) -> IO a
propagateGError ((Ptr (Ptr GError) -> IO CInt) -> IO CInt)
-> (Ptr (Ptr GError) -> IO CInt) -> IO CInt
forall a b. (a -> b) -> a -> b
$ Ptr BaseInfo
-> Ptr ()
-> Ptr Argument
-> Int32
-> Ptr Argument
-> Int32
-> Ptr Argument
-> CInt
-> CInt
-> Ptr (Ptr GError)
-> IO CInt
g_callable_info_invoke Ptr BaseInfo
info' Ptr ()
function Ptr Argument
inArgs'' Int32
nInArgs Ptr Argument
outArgs'' Int32
nOutArgs Ptr Argument
returnValue' CInt
isMethod' CInt
throws'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
(Argument -> IO ()) -> [Argument] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Argument -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Argument]
inArgs
(Argument -> IO ()) -> [Argument] -> IO ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Argument -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr [Argument]
outArgs
Argument -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Argument
returnValue
Ptr Argument -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Argument
inArgs''
Ptr Argument -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Argument
outArgs''
() -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
) (do
Ptr Argument -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Argument
inArgs''
Ptr Argument -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr Argument
outArgs''
)
foreign import ccall "g_callable_info_get_return_type" g_callable_info_get_return_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
callableInfoGetReturnType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
callableInfoGetReturnType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
callableInfoGetReturnType BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_callable_info_get_return_type Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"callableInfoGetReturnType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_callable_info_get_return_attribute" g_callable_info_get_return_attribute ::
Ptr GIRepository.BaseInfo.BaseInfo ->
CString ->
IO CString
callableInfoGetReturnAttribute ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> T.Text
-> m T.Text
callableInfoGetReturnAttribute :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Text -> m Text
callableInfoGetReturnAttribute BaseInfo
info Text
name = IO Text -> m Text
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
CString
result <- Ptr BaseInfo -> CString -> IO CString
g_callable_info_get_return_attribute Ptr BaseInfo
info' CString
name'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"callableInfoGetReturnAttribute" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
Text -> IO Text
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
foreign import ccall "g_callable_info_get_n_args" g_callable_info_get_n_args ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
callableInfoGetNArgs ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
callableInfoGetNArgs :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
callableInfoGetNArgs BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_callable_info_get_n_args Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_callable_info_get_instance_ownership_transfer" g_callable_info_get_instance_ownership_transfer ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
callableInfoGetInstanceOwnershipTransfer ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.Transfer
callableInfoGetInstanceOwnershipTransfer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Transfer
callableInfoGetInstanceOwnershipTransfer BaseInfo
info = IO Transfer -> m Transfer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transfer -> m Transfer) -> IO Transfer -> m Transfer
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_callable_info_get_instance_ownership_transfer Ptr BaseInfo
info'
let result' :: Transfer
result' = (Int -> Transfer
forall a. Enum a => Int -> a
toEnum (Int -> Transfer) -> (CUInt -> Int) -> CUInt -> Transfer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Transfer -> IO Transfer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Transfer
result'
foreign import ccall "g_callable_info_get_caller_owns" g_callable_info_get_caller_owns ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
callableInfoGetCallerOwns ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.Transfer
callableInfoGetCallerOwns :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Transfer
callableInfoGetCallerOwns BaseInfo
info = IO Transfer -> m Transfer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transfer -> m Transfer) -> IO Transfer -> m Transfer
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_callable_info_get_caller_owns Ptr BaseInfo
info'
let result' :: Transfer
result' = (Int -> Transfer
forall a. Enum a => Int -> a
toEnum (Int -> Transfer) -> (CUInt -> Int) -> CUInt -> Transfer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Transfer -> IO Transfer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Transfer
result'
foreign import ccall "g_callable_info_get_arg" g_callable_info_get_arg ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Int32 ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
callableInfoGetArg ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> Int32
-> m GIRepository.BaseInfo.BaseInfo
callableInfoGetArg :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> Int32 -> m BaseInfo
callableInfoGetArg BaseInfo
info Int32
n = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> Int32 -> IO (Ptr BaseInfo)
g_callable_info_get_arg Ptr BaseInfo
info' Int32
n
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"callableInfoGetArg" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_callable_info_can_throw_gerror" g_callable_info_can_throw_gerror ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
callableInfoCanThrowGerror ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
callableInfoCanThrowGerror :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
callableInfoCanThrowGerror BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_callable_info_can_throw_gerror Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_arg_info_may_be_null" g_arg_info_may_be_null ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
argInfoMayBeNull ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
argInfoMayBeNull :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
argInfoMayBeNull BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_arg_info_may_be_null Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_arg_info_load_type" g_arg_info_load_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
Ptr GIRepository.BaseInfo.BaseInfo ->
IO ()
argInfoLoadType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m (GIRepository.BaseInfo.BaseInfo)
argInfoLoadType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
argInfoLoadType BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
type_ <- Int -> IO (Ptr BaseInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
SP.callocBoxedBytes Int
72 :: IO (Ptr GIRepository.BaseInfo.BaseInfo)
Ptr BaseInfo -> Ptr BaseInfo -> IO ()
g_arg_info_load_type Ptr BaseInfo
info' Ptr BaseInfo
type_
BaseInfo
type_' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
type_
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
type_'
foreign import ccall "g_arg_info_is_skip" g_arg_info_is_skip ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
argInfoIsSkip ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
argInfoIsSkip :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
argInfoIsSkip BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_arg_info_is_skip Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_arg_info_is_return_value" g_arg_info_is_return_value ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
argInfoIsReturnValue ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
argInfoIsReturnValue :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
argInfoIsReturnValue BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_arg_info_is_return_value Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_arg_info_is_optional" g_arg_info_is_optional ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
argInfoIsOptional ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
argInfoIsOptional :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
argInfoIsOptional BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_arg_info_is_optional Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_arg_info_is_caller_allocates" g_arg_info_is_caller_allocates ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CInt
argInfoIsCallerAllocates ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Bool
argInfoIsCallerAllocates :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Bool
argInfoIsCallerAllocates BaseInfo
info = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CInt
result <- Ptr BaseInfo -> IO CInt
g_arg_info_is_caller_allocates Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
foreign import ccall "g_arg_info_get_type" g_arg_info_get_type ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO (Ptr GIRepository.BaseInfo.BaseInfo)
argInfoGetType ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.BaseInfo.BaseInfo
argInfoGetType :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m BaseInfo
argInfoGetType BaseInfo
info = IO BaseInfo -> m BaseInfo
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO BaseInfo -> m BaseInfo) -> IO BaseInfo -> m BaseInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Ptr BaseInfo
result <- Ptr BaseInfo -> IO (Ptr BaseInfo)
g_arg_info_get_type Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"argInfoGetType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr BaseInfo
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
BaseInfo -> IO BaseInfo
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_arg_info_get_scope" g_arg_info_get_scope ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
argInfoGetScope ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.ScopeType
argInfoGetScope :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m ScopeType
argInfoGetScope BaseInfo
info = IO ScopeType -> m ScopeType
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO ScopeType -> m ScopeType) -> IO ScopeType -> m ScopeType
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_arg_info_get_scope Ptr BaseInfo
info'
let result' :: ScopeType
result' = (Int -> ScopeType
forall a. Enum a => Int -> a
toEnum (Int -> ScopeType) -> (CUInt -> Int) -> CUInt -> ScopeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
ScopeType -> IO ScopeType
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ScopeType
result'
foreign import ccall "g_arg_info_get_ownership_transfer" g_arg_info_get_ownership_transfer ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
argInfoGetOwnershipTransfer ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.Transfer
argInfoGetOwnershipTransfer :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Transfer
argInfoGetOwnershipTransfer BaseInfo
info = IO Transfer -> m Transfer
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Transfer -> m Transfer) -> IO Transfer -> m Transfer
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_arg_info_get_ownership_transfer Ptr BaseInfo
info'
let result' :: Transfer
result' = (Int -> Transfer
forall a. Enum a => Int -> a
toEnum (Int -> Transfer) -> (CUInt -> Int) -> CUInt -> Transfer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Transfer -> IO Transfer
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Transfer
result'
foreign import ccall "g_arg_info_get_direction" g_arg_info_get_direction ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO CUInt
argInfoGetDirection ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m GIRepository.Enums.Direction
argInfoGetDirection :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Direction
argInfoGetDirection BaseInfo
info = IO Direction -> m Direction
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Direction -> m Direction) -> IO Direction -> m Direction
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
CUInt
result <- Ptr BaseInfo -> IO CUInt
g_arg_info_get_direction Ptr BaseInfo
info'
let result' :: Direction
result' = (Int -> Direction
forall a. Enum a => Int -> a
toEnum (Int -> Direction) -> (CUInt -> Int) -> CUInt -> Direction
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CUInt -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral) CUInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Direction -> IO Direction
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Direction
result'
foreign import ccall "g_arg_info_get_destroy" g_arg_info_get_destroy ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
argInfoGetDestroy ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
argInfoGetDestroy :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
argInfoGetDestroy BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_arg_info_get_destroy Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result
foreign import ccall "g_arg_info_get_closure" g_arg_info_get_closure ::
Ptr GIRepository.BaseInfo.BaseInfo ->
IO Int32
argInfoGetClosure ::
(B.CallStack.HasCallStack, MonadIO m) =>
GIRepository.BaseInfo.BaseInfo
-> m Int32
argInfoGetClosure :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
BaseInfo -> m Int32
argInfoGetClosure BaseInfo
info = IO Int32 -> m Int32
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Int32 -> m Int32) -> IO Int32 -> m Int32
forall a b. (a -> b) -> a -> b
$ do
Ptr BaseInfo
info' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info
Int32
result <- Ptr BaseInfo -> IO Int32
g_arg_info_get_closure Ptr BaseInfo
info'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Int32 -> IO Int32
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
result