#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 ,
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 ,
objectInfoGetFundamental ,
objectInfoGetGetValueFunction ,
objectInfoGetInterface ,
objectInfoGetMethod ,
objectInfoGetNConstants ,
objectInfoGetNFields ,
objectInfoGetNInterfaces ,
objectInfoGetNMethods ,
objectInfoGetNProperties ,
objectInfoGetNSignals ,
objectInfoGetNVfuncs ,
objectInfoGetParent ,
objectInfoGetProperty ,
objectInfoGetRefFunction ,
objectInfoGetSetValueFunction ,
objectInfoGetSignal ,
objectInfoGetTypeInit ,
objectInfoGetTypeName ,
objectInfoGetUnrefFunction ,
objectInfoGetVfunc ,
propertyInfoGetFlags ,
propertyInfoGetOwnershipTransfer ,
propertyInfoGetType ,
registeredTypeInfoGetGType ,
registeredTypeInfoGetTypeInit ,
registeredTypeInfoGetTypeName ,
signalInfoGetClassClosure ,
signalInfoGetFlags ,
signalInfoTrueStopsEmit ,
structInfoFindField ,
structInfoFindMethod ,
structInfoGetAlignment ,
structInfoGetField ,
structInfoGetMethod ,
structInfoGetNFields ,
structInfoGetNMethods ,
structInfoGetSize ,
structInfoIsForeign ,
structInfoIsGtypeStruct ,
typeInfoGetArrayFixedSize ,
typeInfoGetArrayLength ,
typeInfoGetArrayType ,
typeInfoGetInterface ,
typeInfoGetParamType ,
typeInfoGetTag ,
typeInfoIsPointer ,
typeInfoIsZeroTerminated ,
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.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
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 {-# 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 :: BaseInfo -> m BaseInfo
vfuncInfoGetSignal info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "vfuncInfoGetSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Int32
vfuncInfoGetOffset info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m BaseInfo
vfuncInfoGetInvoker info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "vfuncInfoGetInvoker" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m [VFuncInfoFlags]
vfuncInfoGetFlags info :: BaseInfo
info = IO [VFuncInfoFlags] -> m [VFuncInfoFlags]
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 (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 :: BaseInfo -> GType -> m (Ptr ())
vfuncInfoGetAddress info :: BaseInfo
info implementorGtype :: GType
implementorGtype = IO (Ptr ()) -> m (Ptr ())
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 (m :: * -> *) a. Monad m => a -> m a
return Ptr ()
result
) (do
() -> IO ()
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 :: BaseInfo -> m Int64
valueInfoGetValue info :: BaseInfo
info = IO Int64 -> m Int64
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 (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 :: BaseInfo -> m Bool
unionInfoIsDiscriminated info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m CGType
unionInfoGetSize info :: BaseInfo
info = IO CGType -> m CGType
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 (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 :: BaseInfo -> m Int32
unionInfoGetNMethods info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
unionInfoGetNFields info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
unionInfoGetMethod info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "unionInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
unionInfoGetField info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "unionInfoGetField" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m BaseInfo
unionInfoGetDiscriminatorType info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "unionInfoGetDiscriminatorType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Int32
unionInfoGetDiscriminatorOffset info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
unionInfoGetDiscriminator info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "unionInfoGetDiscriminator" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m CGType
unionInfoGetAlignment info :: BaseInfo
info = IO CGType -> m CGType
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 (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 :: BaseInfo -> Text -> m BaseInfo
unionInfoFindMethod info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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 "unionInfoFindMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: TypeTag -> m Text
typeTagToString type_ :: TypeTag
type_ = IO Text -> m Text
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 "typeTagToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
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 :: BaseInfo -> m Bool
typeInfoIsZeroTerminated info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m Bool
typeInfoIsPointer info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
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 :: BaseInfo -> m TypeTag
typeInfoGetTag info :: BaseInfo
info = IO TypeTag -> m TypeTag
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
typeInfoGetParamType info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "typeInfoGetParamType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m BaseInfo
typeInfoGetInterface info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "typeInfoGetInterface" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m ArrayType
typeInfoGetArrayType info :: BaseInfo
info = IO ArrayType -> m ArrayType
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 (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 :: BaseInfo -> m Int32
typeInfoGetArrayLength info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
typeInfoGetArrayFixedSize info :: BaseInfo
info = IO Int32 -> m Int32
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 (m :: * -> *) a. Monad m => a -> m a
return Int32
result
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 :: BaseInfo -> m Bool
structInfoIsGtypeStruct info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m Bool
structInfoIsForeign info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m CGType
structInfoGetSize info :: BaseInfo
info = IO CGType -> m CGType
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 (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 :: BaseInfo -> m Int32
structInfoGetNMethods info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
structInfoGetNFields info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
structInfoGetMethod info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "structInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
structInfoGetField info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "structInfoGetField" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m CGType
structInfoGetAlignment info :: BaseInfo
info = IO CGType -> m CGType
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 (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 :: BaseInfo -> Text -> m BaseInfo
structInfoFindMethod info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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 "structInfoFindMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Text -> m BaseInfo
structInfoFindField info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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 "structInfoFindField" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Bool
signalInfoTrueStopsEmit info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m [SignalFlags]
signalInfoGetFlags info :: BaseInfo
info = IO [SignalFlags] -> m [SignalFlags]
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 (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 :: BaseInfo -> m BaseInfo
signalInfoGetClassClosure info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "signalInfoGetClassClosure" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Text
registeredTypeInfoGetTypeName info :: BaseInfo
info = IO Text -> m Text
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 "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 (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 :: BaseInfo -> m Text
registeredTypeInfoGetTypeInit info :: BaseInfo
info = IO Text -> m Text
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 "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 (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 :: BaseInfo -> m GType
registeredTypeInfoGetGType info :: BaseInfo
info = IO GType -> m GType
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 (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 :: BaseInfo -> m BaseInfo
propertyInfoGetType info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "propertyInfoGetType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
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 :: BaseInfo -> m Transfer
propertyInfoGetOwnershipTransfer info :: BaseInfo
info = IO Transfer -> m Transfer
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 (m :: * -> *) a. Monad m => a -> m a
return Transfer
result'
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 :: BaseInfo -> m [ParamFlags]
propertyInfoGetFlags info :: BaseInfo
info = IO [ParamFlags] -> m [ParamFlags]
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
objectInfoGetVfunc info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "objectInfoGetVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 T.Text
objectInfoGetUnrefFunction :: BaseInfo -> m Text
objectInfoGetUnrefFunction info :: BaseInfo
info = IO Text -> m Text
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_unref_function Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoGetUnrefFunction" 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 (m :: * -> *) a. Monad m => a -> m a
return Text
result'
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 :: BaseInfo -> m Text
objectInfoGetTypeName info :: BaseInfo
info = IO Text -> m Text
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 "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 (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 :: BaseInfo -> m Text
objectInfoGetTypeInit info :: BaseInfo
info = IO Text -> m Text
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 "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 (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 :: BaseInfo -> Int32 -> m BaseInfo
objectInfoGetSignal info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "objectInfoGetSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 T.Text
objectInfoGetSetValueFunction :: BaseInfo -> m Text
objectInfoGetSetValueFunction info :: BaseInfo
info = IO Text -> m Text
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_set_value_function Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoGetSetValueFunction" 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 (m :: * -> *) a. Monad m => a -> m a
return Text
result'
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 T.Text
objectInfoGetRefFunction :: BaseInfo -> m Text
objectInfoGetRefFunction info :: BaseInfo
info = IO Text -> m Text
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_ref_function Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoGetRefFunction" 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 (m :: * -> *) a. Monad m => a -> m a
return Text
result'
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 :: BaseInfo -> Int32 -> m BaseInfo
objectInfoGetProperty info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "objectInfoGetProperty" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 GIRepository.BaseInfo.BaseInfo
objectInfoGetParent :: BaseInfo -> m BaseInfo
objectInfoGetParent info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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_object_info_get_parent Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoGetParent" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
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 :: BaseInfo -> m Int32
objectInfoGetNVfuncs info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
objectInfoGetNSignals info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
objectInfoGetNProperties info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
objectInfoGetNMethods info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
objectInfoGetNInterfaces info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
objectInfoGetNFields info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
objectInfoGetNConstants info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
objectInfoGetMethod info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "objectInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
objectInfoGetInterface info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "objectInfoGetInterface" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 T.Text
objectInfoGetGetValueFunction :: BaseInfo -> m Text
objectInfoGetGetValueFunction info :: BaseInfo
info = IO Text -> m Text
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_get_value_function Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoGetGetValueFunction" 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 (m :: * -> *) a. Monad m => a -> m a
return Text
result'
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 :: BaseInfo -> m Bool
objectInfoGetFundamental info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> Int32 -> m BaseInfo
objectInfoGetField info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "objectInfoGetField" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
objectInfoGetConstant info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "objectInfoGetConstant" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 GIRepository.BaseInfo.BaseInfo
objectInfoGetClassStruct :: BaseInfo -> m BaseInfo
objectInfoGetClassStruct info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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_object_info_get_class_struct Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoGetClassStruct" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
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 :: BaseInfo -> m Bool
objectInfoGetAbstract info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 ((GIRepository.BaseInfo.BaseInfo, GIRepository.BaseInfo.BaseInfo))
objectInfoFindVfuncUsingInterfaces :: BaseInfo -> Text -> m (BaseInfo, BaseInfo)
objectInfoFindVfuncUsingInterfaces info :: BaseInfo
info name :: Text
name = IO (BaseInfo, BaseInfo) -> m (BaseInfo, BaseInfo)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (BaseInfo, BaseInfo) -> m (BaseInfo, BaseInfo))
-> IO (BaseInfo, BaseInfo) -> m (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)
allocMem :: 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
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoFindVfuncUsingInterfaces" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr 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, BoxedObject 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
(BaseInfo, BaseInfo) -> IO (BaseInfo, BaseInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return (BaseInfo
result', 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 GIRepository.BaseInfo.BaseInfo
objectInfoFindVfunc :: BaseInfo -> Text -> m BaseInfo
objectInfoFindVfunc info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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_object_info_find_vfunc Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoFindVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
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 GIRepository.BaseInfo.BaseInfo
objectInfoFindSignal :: BaseInfo -> Text -> m BaseInfo
objectInfoFindSignal info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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_object_info_find_signal Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoFindSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
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 ((GIRepository.BaseInfo.BaseInfo, GIRepository.BaseInfo.BaseInfo))
objectInfoFindMethodUsingInterfaces :: BaseInfo -> Text -> m (BaseInfo, BaseInfo)
objectInfoFindMethodUsingInterfaces info :: BaseInfo
info name :: Text
name = IO (BaseInfo, BaseInfo) -> m (BaseInfo, BaseInfo)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (BaseInfo, BaseInfo) -> m (BaseInfo, BaseInfo))
-> IO (BaseInfo, BaseInfo) -> m (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)
allocMem :: 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
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoFindMethodUsingInterfaces" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
GIRepository.BaseInfo.BaseInfo) Ptr 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, BoxedObject 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
(BaseInfo, BaseInfo) -> IO (BaseInfo, BaseInfo)
forall (m :: * -> *) a. Monad m => a -> m a
return (BaseInfo
result', 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 GIRepository.BaseInfo.BaseInfo
objectInfoFindMethod :: BaseInfo -> Text -> m BaseInfo
objectInfoFindMethod info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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_object_info_find_method Ptr BaseInfo
info' CString
name'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "objectInfoFindMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
result'
foreign import ccall "g_invoke_error_quark" g_invoke_error_quark ::
IO Word32
invokeErrorQuark ::
(B.CallStack.HasCallStack, MonadIO m) =>
m Word32
invokeErrorQuark :: m Word32
invokeErrorQuark = IO Word32 -> m Word32
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetVfunc info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "interfaceInfoGetVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetSignal info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "interfaceInfoGetSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetProperty info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "interfaceInfoGetProperty" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetPrerequisite info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "interfaceInfoGetPrerequisite" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Int32
interfaceInfoGetNVfuncs info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
interfaceInfoGetNSignals info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
interfaceInfoGetNProperties info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
interfaceInfoGetNPrerequisites info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
interfaceInfoGetNMethods info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
interfaceInfoGetNConstants info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetMethod info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "interfaceInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m BaseInfo
interfaceInfoGetIfaceStruct info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "interfaceInfoGetIfaceStruct" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
interfaceInfoGetConstant info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "interfaceInfoGetConstant" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Text -> m BaseInfo
interfaceInfoFindVfunc info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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 "interfaceInfoFindVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Text -> m BaseInfo
interfaceInfoFindSignal info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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 "interfaceInfoFindSignal" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Text -> m BaseInfo
interfaceInfoFindMethod info :: BaseInfo
info name :: Text
name = IO BaseInfo -> m BaseInfo
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 "interfaceInfoFindMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: InfoType -> m Text
infoTypeToString type_ :: InfoType
type_ = IO Text -> m Text
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 "infoTypeToString" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
Text -> IO Text
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 :: InfoType -> BaseInfo -> Typelib -> Word32 -> m BaseInfo
infoNew type_ :: InfoType
type_ container :: BaseInfo
container typelib :: Typelib
typelib offset :: Word32
offset = IO BaseInfo -> m BaseInfo
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 "infoNew" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
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 :: BaseInfo -> m BaseInfo
functionInfoGetVfunc info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "functionInfoGetVfunc" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Text
functionInfoGetSymbol info :: BaseInfo
info = IO Text -> m Text
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 "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 (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 :: BaseInfo -> m BaseInfo
functionInfoGetProperty info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "functionInfoGetProperty" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m [FunctionInfoFlags]
functionInfoGetFlags info :: BaseInfo
info = IO [FunctionInfoFlags] -> m [FunctionInfoFlags]
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 (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 :: BaseInfo -> m BaseInfo
fieldInfoGetType info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "fieldInfoGetType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Int32
fieldInfoGetSize info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
fieldInfoGetOffset info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m [FieldInfoFlags]
fieldInfoGetFlags info :: BaseInfo
info = IO [FieldInfoFlags] -> m [FieldInfoFlags]
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
enumInfoGetValue info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "enumInfoGetValue" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m TypeTag
enumInfoGetStorageType info :: BaseInfo
info = IO TypeTag -> m TypeTag
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 (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 :: BaseInfo -> m Int32
enumInfoGetNValues info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
enumInfoGetNMethods info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
enumInfoGetMethod info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "enumInfoGetMethod" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Text
enumInfoGetErrorDomain info :: BaseInfo
info = IO Text -> m Text
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 "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 (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 :: BaseInfo -> m BaseInfo
constantInfoGetType info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "constantInfoGetType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: GClosure a
-> GValue -> Word32 -> GValue -> Ptr () -> Ptr () -> m ()
cclosureMarshalGeneric closure :: GClosure a
closure returnGvalue :: GValue
returnGvalue nParamValues :: Word32
nParamValues paramValues :: GValue
paramValues invocationHint :: Ptr ()
invocationHint marshalData :: Ptr ()
marshalData = IO () -> m ()
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 (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 :: BaseInfo -> m Bool
callableInfoSkipReturn info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m Bool
callableInfoMayReturnNull info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m BaseInfo
callableInfoLoadReturnType info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 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, BoxedObject 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 (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 :: BaseInfo -> Int32 -> m BaseInfo
callableInfoLoadArg info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 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, BoxedObject 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 (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 :: BaseInfo -> AttributeIter -> m (Bool, Text, Text)
callableInfoIterateReturnAttributes info :: BaseInfo
info iterator :: AttributeIter
iterator = IO (Bool, Text, Text) -> m (Bool, Text, Text)
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)
allocMem :: IO (Ptr CString)
Ptr CString
value <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
allocMem :: 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
/= 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 (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 :: BaseInfo -> m Bool
callableInfoIsMethod info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo
-> Ptr ()
-> [Argument]
-> [Argument]
-> Argument
-> Bool
-> Bool
-> m ()
callableInfoInvoke info :: BaseInfo
info function :: Ptr ()
function inArgs :: [Argument]
inArgs outArgs :: [Argument]
outArgs returnValue :: Argument
returnValue isMethod :: Bool
isMethod throws :: Bool
throws = IO () -> m ()
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 (t :: * -> *) a. Foldable t => t a -> Int
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 (t :: * -> *) a. Foldable t => t a -> Int
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)
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 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)
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 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 (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 :: BaseInfo -> m BaseInfo
callableInfoGetReturnType info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "callableInfoGetReturnType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> Text -> m Text
callableInfoGetReturnAttribute info :: BaseInfo
info name :: Text
name = IO Text -> m Text
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 "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 (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 :: BaseInfo -> m Int32
callableInfoGetNArgs info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Transfer
callableInfoGetInstanceOwnershipTransfer info :: BaseInfo
info = IO Transfer -> m Transfer
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 (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 :: BaseInfo -> m Transfer
callableInfoGetCallerOwns info :: BaseInfo
info = IO Transfer -> m Transfer
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 (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 :: BaseInfo -> Int32 -> m BaseInfo
callableInfoGetArg info :: BaseInfo
info n :: Int32
n = IO BaseInfo -> m BaseInfo
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 "callableInfoGetArg" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m Bool
callableInfoCanThrowGerror info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m Bool
argInfoMayBeNull info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m BaseInfo
argInfoLoadType info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 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, BoxedObject 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 (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 :: BaseInfo -> m Bool
argInfoIsSkip info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m Bool
argInfoIsReturnValue info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m Bool
argInfoIsOptional info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m Bool
argInfoIsCallerAllocates info :: BaseInfo
info = IO Bool -> m Bool
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
/= 0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
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 :: BaseInfo -> m BaseInfo
argInfoGetType info :: BaseInfo
info = IO BaseInfo -> m BaseInfo
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 "argInfoGetType" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, BoxedObject 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 (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 :: BaseInfo -> m ScopeType
argInfoGetScope info :: BaseInfo
info = IO ScopeType -> m ScopeType
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 (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 :: BaseInfo -> m Transfer
argInfoGetOwnershipTransfer info :: BaseInfo
info = IO Transfer -> m Transfer
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 (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 :: BaseInfo -> m Direction
argInfoGetDirection info :: BaseInfo
info = IO Direction -> m Direction
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 (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 :: BaseInfo -> m Int32
argInfoGetDestroy info :: BaseInfo
info = IO Int32 -> m Int32
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 (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 :: BaseInfo -> m Int32
argInfoGetClosure info :: BaseInfo
info = IO Int32 -> m Int32
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 (m :: * -> *) a. Monad m => a -> m a
return Int32
result