{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Gio.Structs.DBusInterfaceInfo
(
DBusInterfaceInfo(..) ,
newZeroDBusInterfaceInfo ,
#if defined(ENABLE_OVERLOADING)
ResolveDBusInterfaceInfoMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
DBusInterfaceInfoCacheBuildMethodInfo ,
#endif
dBusInterfaceInfoCacheBuild ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceInfoCacheReleaseMethodInfo ,
#endif
dBusInterfaceInfoCacheRelease ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceInfoGenerateXmlMethodInfo ,
#endif
dBusInterfaceInfoGenerateXml ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceInfoLookupMethodMethodInfo ,
#endif
dBusInterfaceInfoLookupMethod ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceInfoLookupPropertyMethodInfo,
#endif
dBusInterfaceInfoLookupProperty ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceInfoLookupSignalMethodInfo ,
#endif
dBusInterfaceInfoLookupSignal ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceInfoRefMethodInfo ,
#endif
dBusInterfaceInfoRef ,
#if defined(ENABLE_OVERLOADING)
DBusInterfaceInfoUnrefMethodInfo ,
#endif
dBusInterfaceInfoUnref ,
clearDBusInterfaceInfoAnnotations ,
#if defined(ENABLE_OVERLOADING)
dBusInterfaceInfo_annotations ,
#endif
getDBusInterfaceInfoAnnotations ,
setDBusInterfaceInfoAnnotations ,
clearDBusInterfaceInfoMethods ,
#if defined(ENABLE_OVERLOADING)
dBusInterfaceInfo_methods ,
#endif
getDBusInterfaceInfoMethods ,
setDBusInterfaceInfoMethods ,
clearDBusInterfaceInfoName ,
#if defined(ENABLE_OVERLOADING)
dBusInterfaceInfo_name ,
#endif
getDBusInterfaceInfoName ,
setDBusInterfaceInfoName ,
clearDBusInterfaceInfoProperties ,
#if defined(ENABLE_OVERLOADING)
dBusInterfaceInfo_properties ,
#endif
getDBusInterfaceInfoProperties ,
setDBusInterfaceInfoProperties ,
#if defined(ENABLE_OVERLOADING)
dBusInterfaceInfo_refCount ,
#endif
getDBusInterfaceInfoRefCount ,
setDBusInterfaceInfoRefCount ,
clearDBusInterfaceInfoSignals ,
#if defined(ENABLE_OVERLOADING)
dBusInterfaceInfo_signals ,
#endif
getDBusInterfaceInfoSignals ,
setDBusInterfaceInfoSignals ,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GHashTable as B.GHT
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Coerce as Coerce
import qualified Data.Text as T
import qualified Data.Kind as DK
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import qualified GI.GLib.Structs.String as GLib.String
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusAnnotationInfo as Gio.DBusAnnotationInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusMethodInfo as Gio.DBusMethodInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusPropertyInfo as Gio.DBusPropertyInfo
import {-# SOURCE #-} qualified GI.Gio.Structs.DBusSignalInfo as Gio.DBusSignalInfo
newtype DBusInterfaceInfo = DBusInterfaceInfo (SP.ManagedPtr DBusInterfaceInfo)
deriving (DBusInterfaceInfo -> DBusInterfaceInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DBusInterfaceInfo -> DBusInterfaceInfo -> Bool
$c/= :: DBusInterfaceInfo -> DBusInterfaceInfo -> Bool
== :: DBusInterfaceInfo -> DBusInterfaceInfo -> Bool
$c== :: DBusInterfaceInfo -> DBusInterfaceInfo -> Bool
Eq)
instance SP.ManagedPtrNewtype DBusInterfaceInfo where
toManagedPtr :: DBusInterfaceInfo -> ManagedPtr DBusInterfaceInfo
toManagedPtr (DBusInterfaceInfo ManagedPtr DBusInterfaceInfo
p) = ManagedPtr DBusInterfaceInfo
p
foreign import ccall "g_dbus_interface_info_get_type" c_g_dbus_interface_info_get_type ::
IO GType
type instance O.ParentTypes DBusInterfaceInfo = '[]
instance O.HasParentTypes DBusInterfaceInfo
instance B.Types.TypedObject DBusInterfaceInfo where
glibType :: IO GType
glibType = IO GType
c_g_dbus_interface_info_get_type
instance B.Types.GBoxed DBusInterfaceInfo
instance B.GValue.IsGValue (Maybe DBusInterfaceInfo) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_g_dbus_interface_info_get_type
gvalueSet_ :: Ptr GValue -> Maybe DBusInterfaceInfo -> IO ()
gvalueSet_ Ptr GValue
gv Maybe DBusInterfaceInfo
P.Nothing = forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (forall a. Ptr a
FP.nullPtr :: FP.Ptr DBusInterfaceInfo)
gvalueSet_ Ptr GValue
gv (P.Just DBusInterfaceInfo
obj) = forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr DBusInterfaceInfo
obj (forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe DBusInterfaceInfo)
gvalueGet_ Ptr GValue
gv = do
Ptr DBusInterfaceInfo
ptr <- forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr DBusInterfaceInfo)
if Ptr DBusInterfaceInfo
ptr forall a. Eq a => a -> a -> Bool
/= forall a. Ptr a
FP.nullPtr
then forall a. a -> Maybe a
P.Just forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo
DBusInterfaceInfo Ptr DBusInterfaceInfo
ptr
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
P.Nothing
newZeroDBusInterfaceInfo :: MonadIO m => m DBusInterfaceInfo
newZeroDBusInterfaceInfo :: forall (m :: * -> *). MonadIO m => m DBusInterfaceInfo
newZeroDBusInterfaceInfo = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
24 forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo
DBusInterfaceInfo
instance tag ~ 'AttrSet => Constructible DBusInterfaceInfo tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo)
-> [AttrOp DBusInterfaceInfo tag] -> m DBusInterfaceInfo
new ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo
_ [AttrOp DBusInterfaceInfo tag]
attrs = do
DBusInterfaceInfo
o <- forall (m :: * -> *). MonadIO m => m DBusInterfaceInfo
newZeroDBusInterfaceInfo
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set DBusInterfaceInfo
o [AttrOp DBusInterfaceInfo tag]
attrs
forall (m :: * -> *) a. Monad m => a -> m a
return DBusInterfaceInfo
o
getDBusInterfaceInfoRefCount :: MonadIO m => DBusInterfaceInfo -> m Int32
getDBusInterfaceInfoRefCount :: forall (m :: * -> *). MonadIO m => DBusInterfaceInfo -> m Int32
getDBusInterfaceInfoRefCount DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
Int32
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) :: IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDBusInterfaceInfoRefCount :: MonadIO m => DBusInterfaceInfo -> Int32 -> m ()
setDBusInterfaceInfoRefCount :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> Int32 -> m ()
setDBusInterfaceInfoRefCount DBusInterfaceInfo
s Int32
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0) (Int32
val :: Int32)
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoRefCountFieldInfo
instance AttrInfo DBusInterfaceInfoRefCountFieldInfo where
type AttrBaseTypeConstraint DBusInterfaceInfoRefCountFieldInfo = (~) DBusInterfaceInfo
type AttrAllowedOps DBusInterfaceInfoRefCountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DBusInterfaceInfoRefCountFieldInfo = (~) Int32
type AttrTransferTypeConstraint DBusInterfaceInfoRefCountFieldInfo = (~)Int32
type AttrTransferType DBusInterfaceInfoRefCountFieldInfo = Int32
type AttrGetType DBusInterfaceInfoRefCountFieldInfo = Int32
type AttrLabel DBusInterfaceInfoRefCountFieldInfo = "ref_count"
type AttrOrigin DBusInterfaceInfoRefCountFieldInfo = DBusInterfaceInfo
attrGet = getDBusInterfaceInfoRefCount
attrSet = setDBusInterfaceInfoRefCount
attrConstruct = undefined
attrClear = undefined
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.refCount"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#g:attr:refCount"
})
dBusInterfaceInfo_refCount :: AttrLabelProxy "refCount"
dBusInterfaceInfo_refCount = AttrLabelProxy
#endif
getDBusInterfaceInfoName :: MonadIO m => DBusInterfaceInfo -> m (Maybe T.Text)
getDBusInterfaceInfoName :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> m (Maybe Text)
getDBusInterfaceInfoName DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
CString
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) :: IO CString
Maybe Text
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val forall a b. (a -> b) -> a -> b
$ \CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
cstringToText CString
val'
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setDBusInterfaceInfoName :: MonadIO m => DBusInterfaceInfo -> CString -> m ()
setDBusInterfaceInfoName :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> CString -> m ()
setDBusInterfaceInfoName DBusInterfaceInfo
s CString
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (CString
val :: CString)
clearDBusInterfaceInfoName :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoName :: forall (m :: * -> *). MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoName DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
4) (forall a. Ptr a
FP.nullPtr :: CString)
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoNameFieldInfo
instance AttrInfo DBusInterfaceInfoNameFieldInfo where
type AttrBaseTypeConstraint DBusInterfaceInfoNameFieldInfo = (~) DBusInterfaceInfo
type AttrAllowedOps DBusInterfaceInfoNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoNameFieldInfo = (~) CString
type AttrTransferTypeConstraint DBusInterfaceInfoNameFieldInfo = (~)CString
type AttrTransferType DBusInterfaceInfoNameFieldInfo = CString
type AttrGetType DBusInterfaceInfoNameFieldInfo = Maybe T.Text
type AttrLabel DBusInterfaceInfoNameFieldInfo = "name"
type AttrOrigin DBusInterfaceInfoNameFieldInfo = DBusInterfaceInfo
attrGet = getDBusInterfaceInfoName
attrSet = setDBusInterfaceInfoName
attrConstruct = undefined
attrClear = clearDBusInterfaceInfoName
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.name"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#g:attr:name"
})
dBusInterfaceInfo_name :: AttrLabelProxy "name"
dBusInterfaceInfo_name = AttrLabelProxy
#endif
getDBusInterfaceInfoMethods :: MonadIO m => DBusInterfaceInfo -> m (Maybe [Gio.DBusMethodInfo.DBusMethodInfo])
getDBusInterfaceInfoMethods :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> m (Maybe [DBusMethodInfo])
getDBusInterfaceInfoMethods DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr DBusMethodInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) :: IO (Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
Maybe [DBusMethodInfo]
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusMethodInfo)
val forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr DBusMethodInfo)
val' -> do
[Ptr DBusMethodInfo]
val'' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusMethodInfo)
val'
[DBusMethodInfo]
val''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusMethodInfo -> DBusMethodInfo
Gio.DBusMethodInfo.DBusMethodInfo) [Ptr DBusMethodInfo]
val''
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusMethodInfo]
val'''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusMethodInfo]
result
setDBusInterfaceInfoMethods :: MonadIO m => DBusInterfaceInfo -> Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo) -> m ()
setDBusInterfaceInfoMethods :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> Ptr (Ptr DBusMethodInfo) -> m ()
setDBusInterfaceInfoMethods DBusInterfaceInfo
s Ptr (Ptr DBusMethodInfo)
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (Ptr (Ptr DBusMethodInfo)
val :: Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
clearDBusInterfaceInfoMethods :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoMethods :: forall (m :: * -> *). MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoMethods DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
8) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoMethodsFieldInfo
instance AttrInfo DBusInterfaceInfoMethodsFieldInfo where
type AttrBaseTypeConstraint DBusInterfaceInfoMethodsFieldInfo = (~) DBusInterfaceInfo
type AttrAllowedOps DBusInterfaceInfoMethodsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoMethodsFieldInfo = (~) (Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
type AttrTransferTypeConstraint DBusInterfaceInfoMethodsFieldInfo = (~)(Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
type AttrTransferType DBusInterfaceInfoMethodsFieldInfo = (Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
type AttrGetType DBusInterfaceInfoMethodsFieldInfo = Maybe [Gio.DBusMethodInfo.DBusMethodInfo]
type AttrLabel DBusInterfaceInfoMethodsFieldInfo = "methods"
type AttrOrigin DBusInterfaceInfoMethodsFieldInfo = DBusInterfaceInfo
attrGet = getDBusInterfaceInfoMethods
attrSet = setDBusInterfaceInfoMethods
attrConstruct = undefined
attrClear = clearDBusInterfaceInfoMethods
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.methods"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#g:attr:methods"
})
dBusInterfaceInfo_methods :: AttrLabelProxy "methods"
dBusInterfaceInfo_methods = AttrLabelProxy
#endif
getDBusInterfaceInfoSignals :: MonadIO m => DBusInterfaceInfo -> m (Maybe [Gio.DBusSignalInfo.DBusSignalInfo])
getDBusInterfaceInfoSignals :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> m (Maybe [DBusSignalInfo])
getDBusInterfaceInfoSignals DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr DBusSignalInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) :: IO (Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
Maybe [DBusSignalInfo]
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusSignalInfo)
val forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr DBusSignalInfo)
val' -> do
[Ptr DBusSignalInfo]
val'' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusSignalInfo)
val'
[DBusSignalInfo]
val''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusSignalInfo -> DBusSignalInfo
Gio.DBusSignalInfo.DBusSignalInfo) [Ptr DBusSignalInfo]
val''
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusSignalInfo]
val'''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusSignalInfo]
result
setDBusInterfaceInfoSignals :: MonadIO m => DBusInterfaceInfo -> Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo) -> m ()
setDBusInterfaceInfoSignals :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> Ptr (Ptr DBusSignalInfo) -> m ()
setDBusInterfaceInfoSignals DBusInterfaceInfo
s Ptr (Ptr DBusSignalInfo)
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (Ptr (Ptr DBusSignalInfo)
val :: Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
clearDBusInterfaceInfoSignals :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoSignals :: forall (m :: * -> *). MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoSignals DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
12) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoSignalsFieldInfo
instance AttrInfo DBusInterfaceInfoSignalsFieldInfo where
type AttrBaseTypeConstraint DBusInterfaceInfoSignalsFieldInfo = (~) DBusInterfaceInfo
type AttrAllowedOps DBusInterfaceInfoSignalsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoSignalsFieldInfo = (~) (Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
type AttrTransferTypeConstraint DBusInterfaceInfoSignalsFieldInfo = (~)(Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
type AttrTransferType DBusInterfaceInfoSignalsFieldInfo = (Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
type AttrGetType DBusInterfaceInfoSignalsFieldInfo = Maybe [Gio.DBusSignalInfo.DBusSignalInfo]
type AttrLabel DBusInterfaceInfoSignalsFieldInfo = "signals"
type AttrOrigin DBusInterfaceInfoSignalsFieldInfo = DBusInterfaceInfo
attrGet = getDBusInterfaceInfoSignals
attrSet = setDBusInterfaceInfoSignals
attrConstruct = undefined
attrClear = clearDBusInterfaceInfoSignals
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.signals"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#g:attr:signals"
})
dBusInterfaceInfo_signals :: AttrLabelProxy "signals"
dBusInterfaceInfo_signals = AttrLabelProxy
#endif
getDBusInterfaceInfoProperties :: MonadIO m => DBusInterfaceInfo -> m (Maybe [Gio.DBusPropertyInfo.DBusPropertyInfo])
getDBusInterfaceInfoProperties :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> m (Maybe [DBusPropertyInfo])
getDBusInterfaceInfoProperties DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr DBusPropertyInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) :: IO (Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
Maybe [DBusPropertyInfo]
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusPropertyInfo)
val forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr DBusPropertyInfo)
val' -> do
[Ptr DBusPropertyInfo]
val'' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusPropertyInfo)
val'
[DBusPropertyInfo]
val''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusPropertyInfo -> DBusPropertyInfo
Gio.DBusPropertyInfo.DBusPropertyInfo) [Ptr DBusPropertyInfo]
val''
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusPropertyInfo]
val'''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusPropertyInfo]
result
setDBusInterfaceInfoProperties :: MonadIO m => DBusInterfaceInfo -> Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo) -> m ()
setDBusInterfaceInfoProperties :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> Ptr (Ptr DBusPropertyInfo) -> m ()
setDBusInterfaceInfoProperties DBusInterfaceInfo
s Ptr (Ptr DBusPropertyInfo)
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (Ptr (Ptr DBusPropertyInfo)
val :: Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
clearDBusInterfaceInfoProperties :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoProperties :: forall (m :: * -> *). MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoProperties DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
16) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoPropertiesFieldInfo
instance AttrInfo DBusInterfaceInfoPropertiesFieldInfo where
type AttrBaseTypeConstraint DBusInterfaceInfoPropertiesFieldInfo = (~) DBusInterfaceInfo
type AttrAllowedOps DBusInterfaceInfoPropertiesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoPropertiesFieldInfo = (~) (Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
type AttrTransferTypeConstraint DBusInterfaceInfoPropertiesFieldInfo = (~)(Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
type AttrTransferType DBusInterfaceInfoPropertiesFieldInfo = (Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
type AttrGetType DBusInterfaceInfoPropertiesFieldInfo = Maybe [Gio.DBusPropertyInfo.DBusPropertyInfo]
type AttrLabel DBusInterfaceInfoPropertiesFieldInfo = "properties"
type AttrOrigin DBusInterfaceInfoPropertiesFieldInfo = DBusInterfaceInfo
attrGet = getDBusInterfaceInfoProperties
attrSet = setDBusInterfaceInfoProperties
attrConstruct = undefined
attrClear = clearDBusInterfaceInfoProperties
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.properties"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#g:attr:properties"
})
dBusInterfaceInfo_properties :: AttrLabelProxy "properties"
dBusInterfaceInfo_properties = AttrLabelProxy
#endif
getDBusInterfaceInfoAnnotations :: MonadIO m => DBusInterfaceInfo -> m (Maybe [Gio.DBusAnnotationInfo.DBusAnnotationInfo])
getDBusInterfaceInfoAnnotations :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> m (Maybe [DBusAnnotationInfo])
getDBusInterfaceInfoAnnotations DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr DBusAnnotationInfo)
val <- forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) :: IO (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
Maybe [DBusAnnotationInfo]
result <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusAnnotationInfo)
val forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr DBusAnnotationInfo)
val' -> do
[Ptr DBusAnnotationInfo]
val'' <- forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusAnnotationInfo)
val'
[DBusAnnotationInfo]
val''' <- forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusAnnotationInfo -> DBusAnnotationInfo
Gio.DBusAnnotationInfo.DBusAnnotationInfo) [Ptr DBusAnnotationInfo]
val''
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusAnnotationInfo]
val'''
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusAnnotationInfo]
result
setDBusInterfaceInfoAnnotations :: MonadIO m => DBusInterfaceInfo -> Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo) -> m ()
setDBusInterfaceInfoAnnotations :: forall (m :: * -> *).
MonadIO m =>
DBusInterfaceInfo -> Ptr (Ptr DBusAnnotationInfo) -> m ()
setDBusInterfaceInfoAnnotations DBusInterfaceInfo
s Ptr (Ptr DBusAnnotationInfo)
val = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (Ptr (Ptr DBusAnnotationInfo)
val :: Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
clearDBusInterfaceInfoAnnotations :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoAnnotations :: forall (m :: * -> *). MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoAnnotations DBusInterfaceInfo
s = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s forall a b. (a -> b) -> a -> b
$ \Ptr DBusInterfaceInfo
ptr -> do
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
20) (forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoAnnotationsFieldInfo
instance AttrInfo DBusInterfaceInfoAnnotationsFieldInfo where
type AttrBaseTypeConstraint DBusInterfaceInfoAnnotationsFieldInfo = (~) DBusInterfaceInfo
type AttrAllowedOps DBusInterfaceInfoAnnotationsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoAnnotationsFieldInfo = (~) (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrTransferTypeConstraint DBusInterfaceInfoAnnotationsFieldInfo = (~)(Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrTransferType DBusInterfaceInfoAnnotationsFieldInfo = (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrGetType DBusInterfaceInfoAnnotationsFieldInfo = Maybe [Gio.DBusAnnotationInfo.DBusAnnotationInfo]
type AttrLabel DBusInterfaceInfoAnnotationsFieldInfo = "annotations"
type AttrOrigin DBusInterfaceInfoAnnotationsFieldInfo = DBusInterfaceInfo
attrGet = getDBusInterfaceInfoAnnotations
attrSet = setDBusInterfaceInfoAnnotations
attrConstruct = undefined
attrClear = clearDBusInterfaceInfoAnnotations
attrTransfer _ v = do
return v
dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.annotations"
, O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#g:attr:annotations"
})
dBusInterfaceInfo_annotations :: AttrLabelProxy "annotations"
dBusInterfaceInfo_annotations = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList DBusInterfaceInfo
type instance O.AttributeList DBusInterfaceInfo = DBusInterfaceInfoAttributeList
type DBusInterfaceInfoAttributeList = ('[ '("refCount", DBusInterfaceInfoRefCountFieldInfo), '("name", DBusInterfaceInfoNameFieldInfo), '("methods", DBusInterfaceInfoMethodsFieldInfo), '("signals", DBusInterfaceInfoSignalsFieldInfo), '("properties", DBusInterfaceInfoPropertiesFieldInfo), '("annotations", DBusInterfaceInfoAnnotationsFieldInfo)] :: [(Symbol, DK.Type)])
#endif
foreign import ccall "g_dbus_interface_info_cache_build" g_dbus_interface_info_cache_build ::
Ptr DBusInterfaceInfo ->
IO ()
dBusInterfaceInfoCacheBuild ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusInterfaceInfo
-> m ()
dBusInterfaceInfoCacheBuild :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusInterfaceInfo -> m ()
dBusInterfaceInfoCacheBuild DBusInterfaceInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr DBusInterfaceInfo -> IO ()
g_dbus_interface_info_cache_build Ptr DBusInterfaceInfo
info'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoCacheBuildMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DBusInterfaceInfoCacheBuildMethodInfo DBusInterfaceInfo signature where
overloadedMethod = dBusInterfaceInfoCacheBuild
instance O.OverloadedMethodInfo DBusInterfaceInfoCacheBuildMethodInfo DBusInterfaceInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoCacheBuild",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#v:dBusInterfaceInfoCacheBuild"
})
#endif
foreign import ccall "g_dbus_interface_info_cache_release" g_dbus_interface_info_cache_release ::
Ptr DBusInterfaceInfo ->
IO ()
dBusInterfaceInfoCacheRelease ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusInterfaceInfo
-> m ()
dBusInterfaceInfoCacheRelease :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusInterfaceInfo -> m ()
dBusInterfaceInfoCacheRelease DBusInterfaceInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr DBusInterfaceInfo -> IO ()
g_dbus_interface_info_cache_release Ptr DBusInterfaceInfo
info'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoCacheReleaseMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DBusInterfaceInfoCacheReleaseMethodInfo DBusInterfaceInfo signature where
overloadedMethod = dBusInterfaceInfoCacheRelease
instance O.OverloadedMethodInfo DBusInterfaceInfoCacheReleaseMethodInfo DBusInterfaceInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoCacheRelease",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#v:dBusInterfaceInfoCacheRelease"
})
#endif
foreign import ccall "g_dbus_interface_info_generate_xml" g_dbus_interface_info_generate_xml ::
Ptr DBusInterfaceInfo ->
Word32 ->
Ptr GLib.String.String ->
IO ()
dBusInterfaceInfoGenerateXml ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusInterfaceInfo
-> Word32
-> GLib.String.String
-> m ()
dBusInterfaceInfoGenerateXml :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusInterfaceInfo -> Word32 -> String -> m ()
dBusInterfaceInfoGenerateXml DBusInterfaceInfo
info Word32
indent String
stringBuilder = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr String
stringBuilder' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr String
stringBuilder
Ptr DBusInterfaceInfo -> Word32 -> Ptr String -> IO ()
g_dbus_interface_info_generate_xml Ptr DBusInterfaceInfo
info' Word32
indent Ptr String
stringBuilder'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
stringBuilder
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoGenerateXmlMethodInfo
instance (signature ~ (Word32 -> GLib.String.String -> m ()), MonadIO m) => O.OverloadedMethod DBusInterfaceInfoGenerateXmlMethodInfo DBusInterfaceInfo signature where
overloadedMethod = dBusInterfaceInfoGenerateXml
instance O.OverloadedMethodInfo DBusInterfaceInfoGenerateXmlMethodInfo DBusInterfaceInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoGenerateXml",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#v:dBusInterfaceInfoGenerateXml"
})
#endif
foreign import ccall "g_dbus_interface_info_lookup_method" g_dbus_interface_info_lookup_method ::
Ptr DBusInterfaceInfo ->
CString ->
IO (Ptr Gio.DBusMethodInfo.DBusMethodInfo)
dBusInterfaceInfoLookupMethod ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusInterfaceInfo
-> T.Text
-> m (Maybe Gio.DBusMethodInfo.DBusMethodInfo)
dBusInterfaceInfoLookupMethod :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusInterfaceInfo -> Text -> m (Maybe DBusMethodInfo)
dBusInterfaceInfoLookupMethod DBusInterfaceInfo
info Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr DBusMethodInfo
result <- Ptr DBusInterfaceInfo -> CString -> IO (Ptr DBusMethodInfo)
g_dbus_interface_info_lookup_method Ptr DBusInterfaceInfo
info' CString
name'
Maybe DBusMethodInfo
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DBusMethodInfo
result forall a b. (a -> b) -> a -> b
$ \Ptr DBusMethodInfo
result' -> do
DBusMethodInfo
result'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusMethodInfo -> DBusMethodInfo
Gio.DBusMethodInfo.DBusMethodInfo) Ptr DBusMethodInfo
result'
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMethodInfo
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DBusMethodInfo
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoLookupMethodMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gio.DBusMethodInfo.DBusMethodInfo)), MonadIO m) => O.OverloadedMethod DBusInterfaceInfoLookupMethodMethodInfo DBusInterfaceInfo signature where
overloadedMethod = dBusInterfaceInfoLookupMethod
instance O.OverloadedMethodInfo DBusInterfaceInfoLookupMethodMethodInfo DBusInterfaceInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoLookupMethod",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#v:dBusInterfaceInfoLookupMethod"
})
#endif
foreign import ccall "g_dbus_interface_info_lookup_property" g_dbus_interface_info_lookup_property ::
Ptr DBusInterfaceInfo ->
CString ->
IO (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo)
dBusInterfaceInfoLookupProperty ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusInterfaceInfo
-> T.Text
-> m (Maybe Gio.DBusPropertyInfo.DBusPropertyInfo)
dBusInterfaceInfoLookupProperty :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusInterfaceInfo -> Text -> m (Maybe DBusPropertyInfo)
dBusInterfaceInfoLookupProperty DBusInterfaceInfo
info Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr DBusPropertyInfo
result <- Ptr DBusInterfaceInfo -> CString -> IO (Ptr DBusPropertyInfo)
g_dbus_interface_info_lookup_property Ptr DBusInterfaceInfo
info' CString
name'
Maybe DBusPropertyInfo
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DBusPropertyInfo
result forall a b. (a -> b) -> a -> b
$ \Ptr DBusPropertyInfo
result' -> do
DBusPropertyInfo
result'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusPropertyInfo -> DBusPropertyInfo
Gio.DBusPropertyInfo.DBusPropertyInfo) Ptr DBusPropertyInfo
result'
forall (m :: * -> *) a. Monad m => a -> m a
return DBusPropertyInfo
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DBusPropertyInfo
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoLookupPropertyMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gio.DBusPropertyInfo.DBusPropertyInfo)), MonadIO m) => O.OverloadedMethod DBusInterfaceInfoLookupPropertyMethodInfo DBusInterfaceInfo signature where
overloadedMethod = dBusInterfaceInfoLookupProperty
instance O.OverloadedMethodInfo DBusInterfaceInfoLookupPropertyMethodInfo DBusInterfaceInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoLookupProperty",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#v:dBusInterfaceInfoLookupProperty"
})
#endif
foreign import ccall "g_dbus_interface_info_lookup_signal" g_dbus_interface_info_lookup_signal ::
Ptr DBusInterfaceInfo ->
CString ->
IO (Ptr Gio.DBusSignalInfo.DBusSignalInfo)
dBusInterfaceInfoLookupSignal ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusInterfaceInfo
-> T.Text
-> m (Maybe Gio.DBusSignalInfo.DBusSignalInfo)
dBusInterfaceInfoLookupSignal :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusInterfaceInfo -> Text -> m (Maybe DBusSignalInfo)
dBusInterfaceInfoLookupSignal DBusInterfaceInfo
info Text
name = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
CString
name' <- Text -> IO CString
textToCString Text
name
Ptr DBusSignalInfo
result <- Ptr DBusInterfaceInfo -> CString -> IO (Ptr DBusSignalInfo)
g_dbus_interface_info_lookup_signal Ptr DBusInterfaceInfo
info' CString
name'
Maybe DBusSignalInfo
maybeResult <- forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr DBusSignalInfo
result forall a b. (a -> b) -> a -> b
$ \Ptr DBusSignalInfo
result' -> do
DBusSignalInfo
result'' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusSignalInfo -> DBusSignalInfo
Gio.DBusSignalInfo.DBusSignalInfo) Ptr DBusSignalInfo
result'
forall (m :: * -> *) a. Monad m => a -> m a
return DBusSignalInfo
result''
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
forall a. Ptr a -> IO ()
freeMem CString
name'
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe DBusSignalInfo
maybeResult
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoLookupSignalMethodInfo
instance (signature ~ (T.Text -> m (Maybe Gio.DBusSignalInfo.DBusSignalInfo)), MonadIO m) => O.OverloadedMethod DBusInterfaceInfoLookupSignalMethodInfo DBusInterfaceInfo signature where
overloadedMethod = dBusInterfaceInfoLookupSignal
instance O.OverloadedMethodInfo DBusInterfaceInfoLookupSignalMethodInfo DBusInterfaceInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoLookupSignal",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#v:dBusInterfaceInfoLookupSignal"
})
#endif
foreign import ccall "g_dbus_interface_info_ref" g_dbus_interface_info_ref ::
Ptr DBusInterfaceInfo ->
IO (Ptr DBusInterfaceInfo)
dBusInterfaceInfoRef ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusInterfaceInfo
-> m DBusInterfaceInfo
dBusInterfaceInfoRef :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusInterfaceInfo -> m DBusInterfaceInfo
dBusInterfaceInfoRef DBusInterfaceInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr DBusInterfaceInfo
result <- Ptr DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
g_dbus_interface_info_ref Ptr DBusInterfaceInfo
info'
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"dBusInterfaceInfoRef" Ptr DBusInterfaceInfo
result
DBusInterfaceInfo
result' <- (forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo
DBusInterfaceInfo) Ptr DBusInterfaceInfo
result
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return DBusInterfaceInfo
result'
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoRefMethodInfo
instance (signature ~ (m DBusInterfaceInfo), MonadIO m) => O.OverloadedMethod DBusInterfaceInfoRefMethodInfo DBusInterfaceInfo signature where
overloadedMethod = dBusInterfaceInfoRef
instance O.OverloadedMethodInfo DBusInterfaceInfoRefMethodInfo DBusInterfaceInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoRef",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#v:dBusInterfaceInfoRef"
})
#endif
foreign import ccall "g_dbus_interface_info_unref" g_dbus_interface_info_unref ::
Ptr DBusInterfaceInfo ->
IO ()
dBusInterfaceInfoUnref ::
(B.CallStack.HasCallStack, MonadIO m) =>
DBusInterfaceInfo
-> m ()
dBusInterfaceInfoUnref :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
DBusInterfaceInfo -> m ()
dBusInterfaceInfoUnref DBusInterfaceInfo
info = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr DBusInterfaceInfo -> IO ()
g_dbus_interface_info_unref Ptr DBusInterfaceInfo
info'
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if defined(ENABLE_OVERLOADING)
data DBusInterfaceInfoUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.OverloadedMethod DBusInterfaceInfoUnrefMethodInfo DBusInterfaceInfo signature where
overloadedMethod = dBusInterfaceInfoUnref
instance O.OverloadedMethodInfo DBusInterfaceInfoUnrefMethodInfo DBusInterfaceInfo where
overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
O.resolvedSymbolName = "GI.Gio.Structs.DBusInterfaceInfo.dBusInterfaceInfoUnref",
O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-gio-2.0.30/docs/GI-Gio-Structs-DBusInterfaceInfo.html#v:dBusInterfaceInfoUnref"
})
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveDBusInterfaceInfoMethod (t :: Symbol) (o :: DK.Type) :: DK.Type where
ResolveDBusInterfaceInfoMethod "cacheBuild" o = DBusInterfaceInfoCacheBuildMethodInfo
ResolveDBusInterfaceInfoMethod "cacheRelease" o = DBusInterfaceInfoCacheReleaseMethodInfo
ResolveDBusInterfaceInfoMethod "generateXml" o = DBusInterfaceInfoGenerateXmlMethodInfo
ResolveDBusInterfaceInfoMethod "lookupMethod" o = DBusInterfaceInfoLookupMethodMethodInfo
ResolveDBusInterfaceInfoMethod "lookupProperty" o = DBusInterfaceInfoLookupPropertyMethodInfo
ResolveDBusInterfaceInfoMethod "lookupSignal" o = DBusInterfaceInfoLookupSignalMethodInfo
ResolveDBusInterfaceInfoMethod "ref" o = DBusInterfaceInfoRefMethodInfo
ResolveDBusInterfaceInfoMethod "unref" o = DBusInterfaceInfoUnrefMethodInfo
ResolveDBusInterfaceInfoMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDBusInterfaceInfoMethod t DBusInterfaceInfo, O.OverloadedMethod info DBusInterfaceInfo p) => OL.IsLabel t (DBusInterfaceInfo -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveDBusInterfaceInfoMethod t DBusInterfaceInfo, O.OverloadedMethod info DBusInterfaceInfo p, R.HasField t DBusInterfaceInfo p) => R.HasField t DBusInterfaceInfo p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveDBusInterfaceInfoMethod t DBusInterfaceInfo, O.OverloadedMethodInfo info DBusInterfaceInfo) => OL.IsLabel t (O.MethodProxy info DBusInterfaceInfo) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif