{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.GIRepository.Structs.BaseInfo
(
BaseInfo(..) ,
newZeroBaseInfo ,
#if defined(ENABLE_OVERLOADING)
ResolveBaseInfoMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
BaseInfoEqualMethodInfo ,
#endif
baseInfoEqual ,
#if defined(ENABLE_OVERLOADING)
BaseInfoGetAttributeMethodInfo ,
#endif
baseInfoGetAttribute ,
#if defined(ENABLE_OVERLOADING)
BaseInfoGetContainerMethodInfo ,
#endif
baseInfoGetContainer ,
#if defined(ENABLE_OVERLOADING)
BaseInfoGetNameMethodInfo ,
#endif
baseInfoGetName ,
#if defined(ENABLE_OVERLOADING)
BaseInfoGetNamespaceMethodInfo ,
#endif
baseInfoGetNamespace ,
#if defined(ENABLE_OVERLOADING)
BaseInfoGetTypeMethodInfo ,
#endif
baseInfoGetType ,
#if defined(ENABLE_OVERLOADING)
BaseInfoGetTypelibMethodInfo ,
#endif
baseInfoGetTypelib ,
#if defined(ENABLE_OVERLOADING)
BaseInfoIsDeprecatedMethodInfo ,
#endif
baseInfoIsDeprecated ,
#if defined(ENABLE_OVERLOADING)
BaseInfoIterateAttributesMethodInfo ,
#endif
baseInfoIterateAttributes ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.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 Control.Monad.IO.Class as MIO
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.Structs.AttributeIter as GIRepository.AttributeIter
import {-# SOURCE #-} qualified GI.GIRepository.Structs.Typelib as GIRepository.Typelib
newtype BaseInfo = BaseInfo (SP.ManagedPtr BaseInfo)
deriving (BaseInfo -> BaseInfo -> Bool
(BaseInfo -> BaseInfo -> Bool)
-> (BaseInfo -> BaseInfo -> Bool) -> Eq BaseInfo
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BaseInfo -> BaseInfo -> Bool
$c/= :: BaseInfo -> BaseInfo -> Bool
== :: BaseInfo -> BaseInfo -> Bool
$c== :: BaseInfo -> BaseInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype BaseInfo where
toManagedPtr :: BaseInfo -> ManagedPtr BaseInfo
toManagedPtr (BaseInfo ManagedPtr BaseInfo
p) = ManagedPtr BaseInfo
p
foreign import ccall "g_base_info_gtype_get_type" c_g_base_info_gtype_get_type ::
IO GType
type instance O.ParentTypes BaseInfo = '[]
instance O.HasParentTypes BaseInfo
instance B.Types.TypedObject BaseInfo where
glibType :: IO GType
glibType = IO GType
c_g_base_info_gtype_get_type
instance B.Types.GBoxed BaseInfo
instance B.GValue.IsGValue BaseInfo where
toGValue :: BaseInfo -> IO GValue
toGValue BaseInfo
o = do
GType
gtype <- IO GType
c_g_base_info_gtype_get_type
BaseInfo -> (Ptr BaseInfo -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr BaseInfo
o (GType
-> (GValue -> Ptr BaseInfo -> IO ()) -> Ptr BaseInfo -> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr BaseInfo -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
fromGValue :: GValue -> IO BaseInfo
fromGValue GValue
gv = do
Ptr BaseInfo
ptr <- GValue -> IO (Ptr BaseInfo)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr BaseInfo)
(ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr BaseInfo -> BaseInfo
BaseInfo Ptr BaseInfo
ptr
newZeroBaseInfo :: MonadIO m => m BaseInfo
newZeroBaseInfo :: m BaseInfo
newZeroBaseInfo = 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
$ Int -> IO (Ptr BaseInfo)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
72 IO (Ptr BaseInfo) -> (Ptr BaseInfo -> IO BaseInfo) -> IO BaseInfo
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr BaseInfo -> BaseInfo
BaseInfo
instance tag ~ 'AttrSet => Constructible BaseInfo tag where
new :: (ManagedPtr BaseInfo -> BaseInfo)
-> [AttrOp BaseInfo tag] -> m BaseInfo
new ManagedPtr BaseInfo -> BaseInfo
_ [AttrOp BaseInfo tag]
attrs = do
BaseInfo
o <- m BaseInfo
forall (m :: * -> *). MonadIO m => m BaseInfo
newZeroBaseInfo
BaseInfo -> [AttrOp BaseInfo 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set BaseInfo
o [AttrOp BaseInfo tag]
[AttrOp BaseInfo 'AttrSet]
attrs
BaseInfo -> m BaseInfo
forall (m :: * -> *) a. Monad m => a -> m a
return BaseInfo
o
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList BaseInfo
type instance O.AttributeList BaseInfo = BaseInfoAttributeList
type BaseInfoAttributeList = ('[ ] :: [(Symbol, *)])
#endif
foreign import ccall "g_base_info_equal" g_base_info_equal ::
Ptr BaseInfo ->
Ptr BaseInfo ->
IO CInt
baseInfoEqual ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> BaseInfo
-> m Bool
baseInfoEqual :: BaseInfo -> BaseInfo -> m Bool
baseInfoEqual BaseInfo
info1 BaseInfo
info2 = 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
info1' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info1
Ptr BaseInfo
info2' <- BaseInfo -> IO (Ptr BaseInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr BaseInfo
info2
CInt
result <- Ptr BaseInfo -> Ptr BaseInfo -> IO CInt
g_base_info_equal Ptr BaseInfo
info1' Ptr BaseInfo
info2'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info1
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info2
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BaseInfoEqualMethodInfo
instance (signature ~ (BaseInfo -> m Bool), MonadIO m) => O.MethodInfo BaseInfoEqualMethodInfo BaseInfo signature where
overloadedMethod = baseInfoEqual
#endif
foreign import ccall "g_base_info_get_attribute" g_base_info_get_attribute ::
Ptr BaseInfo ->
CString ->
IO CString
baseInfoGetAttribute ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> T.Text
-> m T.Text
baseInfoGetAttribute :: BaseInfo -> Text -> m Text
baseInfoGetAttribute BaseInfo
info 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_base_info_get_attribute Ptr BaseInfo
info' CString
name'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"baseInfoGetAttribute" 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'
#if defined(ENABLE_OVERLOADING)
data BaseInfoGetAttributeMethodInfo
instance (signature ~ (T.Text -> m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetAttributeMethodInfo BaseInfo signature where
overloadedMethod = baseInfoGetAttribute
#endif
foreign import ccall "g_base_info_get_container" g_base_info_get_container ::
Ptr BaseInfo ->
IO (Ptr BaseInfo)
baseInfoGetContainer ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> m BaseInfo
baseInfoGetContainer :: BaseInfo -> m BaseInfo
baseInfoGetContainer 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_base_info_get_container Ptr BaseInfo
info'
Text -> Ptr BaseInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"baseInfoGetContainer" Ptr BaseInfo
result
BaseInfo
result' <- ((ManagedPtr BaseInfo -> BaseInfo) -> Ptr BaseInfo -> IO BaseInfo
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr BaseInfo -> 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'
#if defined(ENABLE_OVERLOADING)
data BaseInfoGetContainerMethodInfo
instance (signature ~ (m BaseInfo), MonadIO m) => O.MethodInfo BaseInfoGetContainerMethodInfo BaseInfo signature where
overloadedMethod = baseInfoGetContainer
#endif
foreign import ccall "g_base_info_get_name" g_base_info_get_name ::
Ptr BaseInfo ->
IO CString
baseInfoGetName ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> m T.Text
baseInfoGetName :: BaseInfo -> m Text
baseInfoGetName 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_base_info_get_name Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"baseInfoGetName" 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'
#if defined(ENABLE_OVERLOADING)
data BaseInfoGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetNameMethodInfo BaseInfo signature where
overloadedMethod = baseInfoGetName
#endif
foreign import ccall "g_base_info_get_namespace" g_base_info_get_namespace ::
Ptr BaseInfo ->
IO CString
baseInfoGetNamespace ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> m T.Text
baseInfoGetNamespace :: BaseInfo -> m Text
baseInfoGetNamespace 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_base_info_get_namespace Ptr BaseInfo
info'
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"baseInfoGetNamespace" 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'
#if defined(ENABLE_OVERLOADING)
data BaseInfoGetNamespaceMethodInfo
instance (signature ~ (m T.Text), MonadIO m) => O.MethodInfo BaseInfoGetNamespaceMethodInfo BaseInfo signature where
overloadedMethod = baseInfoGetNamespace
#endif
foreign import ccall "g_base_info_get_type" g_base_info_get_type ::
Ptr BaseInfo ->
IO CUInt
baseInfoGetType ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> m GIRepository.Enums.InfoType
baseInfoGetType :: BaseInfo -> m InfoType
baseInfoGetType BaseInfo
info = IO InfoType -> m InfoType
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO InfoType -> m InfoType) -> IO InfoType -> m InfoType
forall a b. (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_base_info_get_type Ptr BaseInfo
info'
let result' :: InfoType
result' = (Int -> InfoType
forall a. Enum a => Int -> a
toEnum (Int -> InfoType) -> (CUInt -> Int) -> CUInt -> InfoType
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
InfoType -> IO InfoType
forall (m :: * -> *) a. Monad m => a -> m a
return InfoType
result'
#if defined(ENABLE_OVERLOADING)
data BaseInfoGetTypeMethodInfo
instance (signature ~ (m GIRepository.Enums.InfoType), MonadIO m) => O.MethodInfo BaseInfoGetTypeMethodInfo BaseInfo signature where
overloadedMethod = baseInfoGetType
#endif
foreign import ccall "g_base_info_get_typelib" g_base_info_get_typelib ::
Ptr BaseInfo ->
IO (Ptr GIRepository.Typelib.Typelib)
baseInfoGetTypelib ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> m GIRepository.Typelib.Typelib
baseInfoGetTypelib :: BaseInfo -> m Typelib
baseInfoGetTypelib BaseInfo
info = IO Typelib -> m Typelib
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Typelib -> m Typelib) -> IO Typelib -> m Typelib
forall a b. (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 Typelib
result <- Ptr BaseInfo -> IO (Ptr Typelib)
g_base_info_get_typelib Ptr BaseInfo
info'
Text -> Ptr Typelib -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"baseInfoGetTypelib" Ptr Typelib
result
Typelib
result' <- ((ManagedPtr Typelib -> Typelib) -> Ptr Typelib -> IO Typelib
forall a.
(HasCallStack, BoxedPtr a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newPtr ManagedPtr Typelib -> Typelib
GIRepository.Typelib.Typelib) Ptr Typelib
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Typelib -> IO Typelib
forall (m :: * -> *) a. Monad m => a -> m a
return Typelib
result'
#if defined(ENABLE_OVERLOADING)
data BaseInfoGetTypelibMethodInfo
instance (signature ~ (m GIRepository.Typelib.Typelib), MonadIO m) => O.MethodInfo BaseInfoGetTypelibMethodInfo BaseInfo signature where
overloadedMethod = baseInfoGetTypelib
#endif
foreign import ccall "g_base_info_is_deprecated" g_base_info_is_deprecated ::
Ptr BaseInfo ->
IO CInt
baseInfoIsDeprecated ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> m Bool
baseInfoIsDeprecated :: BaseInfo -> m Bool
baseInfoIsDeprecated 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_base_info_is_deprecated Ptr BaseInfo
info'
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'
#if defined(ENABLE_OVERLOADING)
data BaseInfoIsDeprecatedMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo BaseInfoIsDeprecatedMethodInfo BaseInfo signature where
overloadedMethod = baseInfoIsDeprecated
#endif
foreign import ccall "g_base_info_iterate_attributes" g_base_info_iterate_attributes ::
Ptr BaseInfo ->
Ptr GIRepository.AttributeIter.AttributeIter ->
Ptr CString ->
Ptr CString ->
IO CInt
baseInfoIterateAttributes ::
(B.CallStack.HasCallStack, MonadIO m) =>
BaseInfo
-> GIRepository.AttributeIter.AttributeIter
-> m ((Bool, T.Text, T.Text))
baseInfoIterateAttributes :: BaseInfo -> AttributeIter -> m (Bool, Text, Text)
baseInfoIterateAttributes BaseInfo
info 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)
callocMem :: IO (Ptr CString)
Ptr CString
value <- IO (Ptr CString)
forall a. Storable a => IO (Ptr a)
callocMem :: IO (Ptr CString)
CInt
result <- Ptr BaseInfo
-> Ptr AttributeIter -> Ptr CString -> Ptr CString -> IO CInt
g_base_info_iterate_attributes Ptr BaseInfo
info' Ptr AttributeIter
iterator' Ptr CString
name Ptr CString
value
let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= CInt
0) CInt
result
CString
name' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
name
Text
name'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
name'
CString
value' <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek Ptr CString
value
Text
value'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
value'
BaseInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr BaseInfo
info
AttributeIter -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr AttributeIter
iterator
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
name
Ptr CString -> IO ()
forall a. Ptr a -> IO ()
freeMem Ptr CString
value
(Bool, Text, Text) -> IO (Bool, Text, Text)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool
result', Text
name'', Text
value'')
#if defined(ENABLE_OVERLOADING)
data BaseInfoIterateAttributesMethodInfo
instance (signature ~ (GIRepository.AttributeIter.AttributeIter -> m ((Bool, T.Text, T.Text))), MonadIO m) => O.MethodInfo BaseInfoIterateAttributesMethodInfo BaseInfo signature where
overloadedMethod = baseInfoIterateAttributes
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveBaseInfoMethod (t :: Symbol) (o :: *) :: * where
ResolveBaseInfoMethod "equal" o = BaseInfoEqualMethodInfo
ResolveBaseInfoMethod "isDeprecated" o = BaseInfoIsDeprecatedMethodInfo
ResolveBaseInfoMethod "iterateAttributes" o = BaseInfoIterateAttributesMethodInfo
ResolveBaseInfoMethod "getAttribute" o = BaseInfoGetAttributeMethodInfo
ResolveBaseInfoMethod "getContainer" o = BaseInfoGetContainerMethodInfo
ResolveBaseInfoMethod "getName" o = BaseInfoGetNameMethodInfo
ResolveBaseInfoMethod "getNamespace" o = BaseInfoGetNamespaceMethodInfo
ResolveBaseInfoMethod "getType" o = BaseInfoGetTypeMethodInfo
ResolveBaseInfoMethod "getTypelib" o = BaseInfoGetTypelibMethodInfo
ResolveBaseInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveBaseInfoMethod t BaseInfo, O.MethodInfo info BaseInfo p) => OL.IsLabel t (BaseInfo -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#endif