#define ENABLE_OVERLOADING \
(!defined(__HADDOCK_VERSION__))
module GI.Gio.Structs.DBusInterfaceInfo
(
DBusInterfaceInfo(..) ,
newZeroDBusInterfaceInfo ,
noDBusInterfaceInfo ,
#if ENABLE_OVERLOADING
DBusInterfaceInfoCacheBuildMethodInfo ,
#endif
dBusInterfaceInfoCacheBuild ,
#if ENABLE_OVERLOADING
DBusInterfaceInfoCacheReleaseMethodInfo ,
#endif
dBusInterfaceInfoCacheRelease ,
#if ENABLE_OVERLOADING
DBusInterfaceInfoGenerateXmlMethodInfo ,
#endif
dBusInterfaceInfoGenerateXml ,
#if ENABLE_OVERLOADING
DBusInterfaceInfoLookupMethodMethodInfo ,
#endif
dBusInterfaceInfoLookupMethod ,
#if ENABLE_OVERLOADING
DBusInterfaceInfoLookupPropertyMethodInfo,
#endif
dBusInterfaceInfoLookupProperty ,
#if ENABLE_OVERLOADING
DBusInterfaceInfoLookupSignalMethodInfo ,
#endif
dBusInterfaceInfoLookupSignal ,
#if ENABLE_OVERLOADING
DBusInterfaceInfoRefMethodInfo ,
#endif
dBusInterfaceInfoRef ,
#if ENABLE_OVERLOADING
DBusInterfaceInfoUnrefMethodInfo ,
#endif
dBusInterfaceInfoUnref ,
clearDBusInterfaceInfoAnnotations ,
#if ENABLE_OVERLOADING
dBusInterfaceInfo_annotations ,
#endif
getDBusInterfaceInfoAnnotations ,
setDBusInterfaceInfoAnnotations ,
clearDBusInterfaceInfoMethods ,
#if ENABLE_OVERLOADING
dBusInterfaceInfo_methods ,
#endif
getDBusInterfaceInfoMethods ,
setDBusInterfaceInfoMethods ,
clearDBusInterfaceInfoName ,
#if ENABLE_OVERLOADING
dBusInterfaceInfo_name ,
#endif
getDBusInterfaceInfoName ,
setDBusInterfaceInfoName ,
clearDBusInterfaceInfoProperties ,
#if ENABLE_OVERLOADING
dBusInterfaceInfo_properties ,
#endif
getDBusInterfaceInfoProperties ,
setDBusInterfaceInfoProperties ,
#if ENABLE_OVERLOADING
dBusInterfaceInfo_refCount ,
#endif
getDBusInterfaceInfoRefCount ,
setDBusInterfaceInfoRefCount ,
clearDBusInterfaceInfoSignals ,
#if 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.ManagedPtr as B.ManagedPtr
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.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
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 (ManagedPtr DBusInterfaceInfo)
foreign import ccall "g_dbus_interface_info_get_type" c_g_dbus_interface_info_get_type ::
IO GType
instance BoxedObject DBusInterfaceInfo where
boxedType :: DBusInterfaceInfo -> IO GType
boxedType _ = IO GType
c_g_dbus_interface_info_get_type
newZeroDBusInterfaceInfo :: MonadIO m => m DBusInterfaceInfo
newZeroDBusInterfaceInfo :: m DBusInterfaceInfo
newZeroDBusInterfaceInfo = IO DBusInterfaceInfo -> m DBusInterfaceInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusInterfaceInfo -> m DBusInterfaceInfo)
-> IO DBusInterfaceInfo -> m DBusInterfaceInfo
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr DBusInterfaceInfo)
forall a. BoxedObject a => Int -> IO (Ptr a)
callocBoxedBytes 48 IO (Ptr DBusInterfaceInfo)
-> (Ptr DBusInterfaceInfo -> IO DBusInterfaceInfo)
-> IO DBusInterfaceInfo
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo)
-> Ptr DBusInterfaceInfo -> IO DBusInterfaceInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo
DBusInterfaceInfo
instance tag ~ 'AttrSet => Constructible DBusInterfaceInfo tag where
new :: (ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo)
-> [AttrOp DBusInterfaceInfo tag] -> m DBusInterfaceInfo
new _ attrs :: [AttrOp DBusInterfaceInfo tag]
attrs = do
DBusInterfaceInfo
o <- m DBusInterfaceInfo
forall (m :: * -> *). MonadIO m => m DBusInterfaceInfo
newZeroDBusInterfaceInfo
DBusInterfaceInfo -> [AttrOp DBusInterfaceInfo 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set DBusInterfaceInfo
o [AttrOp DBusInterfaceInfo tag]
[AttrOp DBusInterfaceInfo 'AttrSet]
attrs
DBusInterfaceInfo -> m DBusInterfaceInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DBusInterfaceInfo
o
noDBusInterfaceInfo :: Maybe DBusInterfaceInfo
noDBusInterfaceInfo :: Maybe DBusInterfaceInfo
noDBusInterfaceInfo = Maybe DBusInterfaceInfo
forall a. Maybe a
Nothing
getDBusInterfaceInfoRefCount :: MonadIO m => DBusInterfaceInfo -> m Int32
getDBusInterfaceInfoRefCount :: DBusInterfaceInfo -> m Int32
getDBusInterfaceInfoRefCount s :: DBusInterfaceInfo
s = 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
$ DBusInterfaceInfo
-> (Ptr DBusInterfaceInfo -> IO Int32) -> IO Int32
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO Int32) -> IO Int32)
-> (Ptr DBusInterfaceInfo -> IO Int32) -> IO Int32
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Int32
val <- Ptr Int32 -> IO Int32
forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) :: IO Int32
Int32 -> IO Int32
forall (m :: * -> *) a. Monad m => a -> m a
return Int32
val
setDBusInterfaceInfoRefCount :: MonadIO m => DBusInterfaceInfo -> Int32 -> m ()
setDBusInterfaceInfoRefCount :: DBusInterfaceInfo -> Int32 -> m ()
setDBusInterfaceInfoRefCount s :: DBusInterfaceInfo
s val :: Int32
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr Int32 -> Int32 -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr Int32
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 0) (Int32
val :: Int32)
#if ENABLE_OVERLOADING
data DBusInterfaceInfoRefCountFieldInfo
instance AttrInfo DBusInterfaceInfoRefCountFieldInfo where
type AttrAllowedOps DBusInterfaceInfoRefCountFieldInfo = '[ 'AttrSet, 'AttrGet]
type AttrSetTypeConstraint DBusInterfaceInfoRefCountFieldInfo = (~) Int32
type AttrBaseTypeConstraint DBusInterfaceInfoRefCountFieldInfo = (~) DBusInterfaceInfo
type AttrGetType DBusInterfaceInfoRefCountFieldInfo = Int32
type AttrLabel DBusInterfaceInfoRefCountFieldInfo = "ref_count"
type AttrOrigin DBusInterfaceInfoRefCountFieldInfo = DBusInterfaceInfo
attrGet _ = getDBusInterfaceInfoRefCount
attrSet _ = setDBusInterfaceInfoRefCount
attrConstruct = undefined
attrClear _ = undefined
dBusInterfaceInfo_refCount :: AttrLabelProxy "refCount"
dBusInterfaceInfo_refCount = AttrLabelProxy
#endif
getDBusInterfaceInfoName :: MonadIO m => DBusInterfaceInfo -> m (Maybe T.Text)
getDBusInterfaceInfoName :: DBusInterfaceInfo -> m (Maybe Text)
getDBusInterfaceInfoName s :: DBusInterfaceInfo
s = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo
-> (Ptr DBusInterfaceInfo -> IO (Maybe Text)) -> IO (Maybe Text)
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO (Maybe Text)) -> IO (Maybe Text))
-> (Ptr DBusInterfaceInfo -> IO (Maybe Text)) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
CString
val <- Ptr CString -> IO CString
forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) :: IO CString
Maybe Text
result <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull CString
val ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \val' :: CString
val' -> do
Text
val'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
val'
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
val''
Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
result
setDBusInterfaceInfoName :: MonadIO m => DBusInterfaceInfo -> CString -> m ()
setDBusInterfaceInfoName :: DBusInterfaceInfo -> CString -> m ()
setDBusInterfaceInfoName s :: DBusInterfaceInfo
s val :: CString
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (CString
val :: CString)
clearDBusInterfaceInfoName :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoName :: DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoName s :: DBusInterfaceInfo
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr CString -> CString -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr CString
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 8) (CString
forall a. Ptr a
FP.nullPtr :: CString)
#if ENABLE_OVERLOADING
data DBusInterfaceInfoNameFieldInfo
instance AttrInfo DBusInterfaceInfoNameFieldInfo where
type AttrAllowedOps DBusInterfaceInfoNameFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoNameFieldInfo = (~) CString
type AttrBaseTypeConstraint DBusInterfaceInfoNameFieldInfo = (~) DBusInterfaceInfo
type AttrGetType DBusInterfaceInfoNameFieldInfo = Maybe T.Text
type AttrLabel DBusInterfaceInfoNameFieldInfo = "name"
type AttrOrigin DBusInterfaceInfoNameFieldInfo = DBusInterfaceInfo
attrGet _ = getDBusInterfaceInfoName
attrSet _ = setDBusInterfaceInfoName
attrConstruct = undefined
attrClear _ = clearDBusInterfaceInfoName
dBusInterfaceInfo_name :: AttrLabelProxy "name"
dBusInterfaceInfo_name = AttrLabelProxy
#endif
getDBusInterfaceInfoMethods :: MonadIO m => DBusInterfaceInfo -> m (Maybe [Gio.DBusMethodInfo.DBusMethodInfo])
getDBusInterfaceInfoMethods :: DBusInterfaceInfo -> m (Maybe [DBusMethodInfo])
getDBusInterfaceInfoMethods s :: DBusInterfaceInfo
s = IO (Maybe [DBusMethodInfo]) -> m (Maybe [DBusMethodInfo])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [DBusMethodInfo]) -> m (Maybe [DBusMethodInfo]))
-> IO (Maybe [DBusMethodInfo]) -> m (Maybe [DBusMethodInfo])
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo
-> (Ptr DBusInterfaceInfo -> IO (Maybe [DBusMethodInfo]))
-> IO (Maybe [DBusMethodInfo])
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO (Maybe [DBusMethodInfo]))
-> IO (Maybe [DBusMethodInfo]))
-> (Ptr DBusInterfaceInfo -> IO (Maybe [DBusMethodInfo]))
-> IO (Maybe [DBusMethodInfo])
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr DBusMethodInfo)
val <- Ptr (Ptr (Ptr DBusMethodInfo)) -> IO (Ptr (Ptr DBusMethodInfo))
forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusMethodInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) :: IO (Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
Maybe [DBusMethodInfo]
result <- Ptr (Ptr DBusMethodInfo)
-> (Ptr (Ptr DBusMethodInfo) -> IO [DBusMethodInfo])
-> IO (Maybe [DBusMethodInfo])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusMethodInfo)
val ((Ptr (Ptr DBusMethodInfo) -> IO [DBusMethodInfo])
-> IO (Maybe [DBusMethodInfo]))
-> (Ptr (Ptr DBusMethodInfo) -> IO [DBusMethodInfo])
-> IO (Maybe [DBusMethodInfo])
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr (Ptr DBusMethodInfo)
val' -> do
[Ptr DBusMethodInfo]
val'' <- Ptr (Ptr DBusMethodInfo) -> IO [Ptr DBusMethodInfo]
forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusMethodInfo)
val'
[DBusMethodInfo]
val''' <- (Ptr DBusMethodInfo -> IO DBusMethodInfo)
-> [Ptr DBusMethodInfo] -> IO [DBusMethodInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr DBusMethodInfo -> DBusMethodInfo)
-> Ptr DBusMethodInfo -> IO DBusMethodInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusMethodInfo -> DBusMethodInfo
Gio.DBusMethodInfo.DBusMethodInfo) [Ptr DBusMethodInfo]
val''
[DBusMethodInfo] -> IO [DBusMethodInfo]
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusMethodInfo]
val'''
Maybe [DBusMethodInfo] -> IO (Maybe [DBusMethodInfo])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusMethodInfo]
result
setDBusInterfaceInfoMethods :: MonadIO m => DBusInterfaceInfo -> Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo) -> m ()
setDBusInterfaceInfoMethods :: DBusInterfaceInfo -> Ptr (Ptr DBusMethodInfo) -> m ()
setDBusInterfaceInfoMethods s :: DBusInterfaceInfo
s val :: Ptr (Ptr DBusMethodInfo)
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr (Ptr DBusMethodInfo)) -> Ptr (Ptr DBusMethodInfo) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusMethodInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr (Ptr DBusMethodInfo)
val :: Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
clearDBusInterfaceInfoMethods :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoMethods :: DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoMethods s :: DBusInterfaceInfo
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr (Ptr DBusMethodInfo)) -> Ptr (Ptr DBusMethodInfo) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusMethodInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 16) (Ptr (Ptr DBusMethodInfo)
forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
#if ENABLE_OVERLOADING
data DBusInterfaceInfoMethodsFieldInfo
instance AttrInfo DBusInterfaceInfoMethodsFieldInfo where
type AttrAllowedOps DBusInterfaceInfoMethodsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoMethodsFieldInfo = (~) (Ptr (Ptr Gio.DBusMethodInfo.DBusMethodInfo))
type AttrBaseTypeConstraint DBusInterfaceInfoMethodsFieldInfo = (~) DBusInterfaceInfo
type AttrGetType DBusInterfaceInfoMethodsFieldInfo = Maybe [Gio.DBusMethodInfo.DBusMethodInfo]
type AttrLabel DBusInterfaceInfoMethodsFieldInfo = "methods"
type AttrOrigin DBusInterfaceInfoMethodsFieldInfo = DBusInterfaceInfo
attrGet _ = getDBusInterfaceInfoMethods
attrSet _ = setDBusInterfaceInfoMethods
attrConstruct = undefined
attrClear _ = clearDBusInterfaceInfoMethods
dBusInterfaceInfo_methods :: AttrLabelProxy "methods"
dBusInterfaceInfo_methods = AttrLabelProxy
#endif
getDBusInterfaceInfoSignals :: MonadIO m => DBusInterfaceInfo -> m (Maybe [Gio.DBusSignalInfo.DBusSignalInfo])
getDBusInterfaceInfoSignals :: DBusInterfaceInfo -> m (Maybe [DBusSignalInfo])
getDBusInterfaceInfoSignals s :: DBusInterfaceInfo
s = IO (Maybe [DBusSignalInfo]) -> m (Maybe [DBusSignalInfo])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [DBusSignalInfo]) -> m (Maybe [DBusSignalInfo]))
-> IO (Maybe [DBusSignalInfo]) -> m (Maybe [DBusSignalInfo])
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo
-> (Ptr DBusInterfaceInfo -> IO (Maybe [DBusSignalInfo]))
-> IO (Maybe [DBusSignalInfo])
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO (Maybe [DBusSignalInfo]))
-> IO (Maybe [DBusSignalInfo]))
-> (Ptr DBusInterfaceInfo -> IO (Maybe [DBusSignalInfo]))
-> IO (Maybe [DBusSignalInfo])
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr DBusSignalInfo)
val <- Ptr (Ptr (Ptr DBusSignalInfo)) -> IO (Ptr (Ptr DBusSignalInfo))
forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusSignalInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) :: IO (Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
Maybe [DBusSignalInfo]
result <- Ptr (Ptr DBusSignalInfo)
-> (Ptr (Ptr DBusSignalInfo) -> IO [DBusSignalInfo])
-> IO (Maybe [DBusSignalInfo])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusSignalInfo)
val ((Ptr (Ptr DBusSignalInfo) -> IO [DBusSignalInfo])
-> IO (Maybe [DBusSignalInfo]))
-> (Ptr (Ptr DBusSignalInfo) -> IO [DBusSignalInfo])
-> IO (Maybe [DBusSignalInfo])
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr (Ptr DBusSignalInfo)
val' -> do
[Ptr DBusSignalInfo]
val'' <- Ptr (Ptr DBusSignalInfo) -> IO [Ptr DBusSignalInfo]
forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusSignalInfo)
val'
[DBusSignalInfo]
val''' <- (Ptr DBusSignalInfo -> IO DBusSignalInfo)
-> [Ptr DBusSignalInfo] -> IO [DBusSignalInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr DBusSignalInfo -> DBusSignalInfo)
-> Ptr DBusSignalInfo -> IO DBusSignalInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusSignalInfo -> DBusSignalInfo
Gio.DBusSignalInfo.DBusSignalInfo) [Ptr DBusSignalInfo]
val''
[DBusSignalInfo] -> IO [DBusSignalInfo]
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusSignalInfo]
val'''
Maybe [DBusSignalInfo] -> IO (Maybe [DBusSignalInfo])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusSignalInfo]
result
setDBusInterfaceInfoSignals :: MonadIO m => DBusInterfaceInfo -> Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo) -> m ()
setDBusInterfaceInfoSignals :: DBusInterfaceInfo -> Ptr (Ptr DBusSignalInfo) -> m ()
setDBusInterfaceInfoSignals s :: DBusInterfaceInfo
s val :: Ptr (Ptr DBusSignalInfo)
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr (Ptr DBusSignalInfo)) -> Ptr (Ptr DBusSignalInfo) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusSignalInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (Ptr (Ptr DBusSignalInfo)
val :: Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
clearDBusInterfaceInfoSignals :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoSignals :: DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoSignals s :: DBusInterfaceInfo
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr (Ptr DBusSignalInfo)) -> Ptr (Ptr DBusSignalInfo) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusSignalInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 24) (Ptr (Ptr DBusSignalInfo)
forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
#if ENABLE_OVERLOADING
data DBusInterfaceInfoSignalsFieldInfo
instance AttrInfo DBusInterfaceInfoSignalsFieldInfo where
type AttrAllowedOps DBusInterfaceInfoSignalsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoSignalsFieldInfo = (~) (Ptr (Ptr Gio.DBusSignalInfo.DBusSignalInfo))
type AttrBaseTypeConstraint DBusInterfaceInfoSignalsFieldInfo = (~) DBusInterfaceInfo
type AttrGetType DBusInterfaceInfoSignalsFieldInfo = Maybe [Gio.DBusSignalInfo.DBusSignalInfo]
type AttrLabel DBusInterfaceInfoSignalsFieldInfo = "signals"
type AttrOrigin DBusInterfaceInfoSignalsFieldInfo = DBusInterfaceInfo
attrGet _ = getDBusInterfaceInfoSignals
attrSet _ = setDBusInterfaceInfoSignals
attrConstruct = undefined
attrClear _ = clearDBusInterfaceInfoSignals
dBusInterfaceInfo_signals :: AttrLabelProxy "signals"
dBusInterfaceInfo_signals = AttrLabelProxy
#endif
getDBusInterfaceInfoProperties :: MonadIO m => DBusInterfaceInfo -> m (Maybe [Gio.DBusPropertyInfo.DBusPropertyInfo])
getDBusInterfaceInfoProperties :: DBusInterfaceInfo -> m (Maybe [DBusPropertyInfo])
getDBusInterfaceInfoProperties s :: DBusInterfaceInfo
s = IO (Maybe [DBusPropertyInfo]) -> m (Maybe [DBusPropertyInfo])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [DBusPropertyInfo]) -> m (Maybe [DBusPropertyInfo]))
-> IO (Maybe [DBusPropertyInfo]) -> m (Maybe [DBusPropertyInfo])
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo
-> (Ptr DBusInterfaceInfo -> IO (Maybe [DBusPropertyInfo]))
-> IO (Maybe [DBusPropertyInfo])
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO (Maybe [DBusPropertyInfo]))
-> IO (Maybe [DBusPropertyInfo]))
-> (Ptr DBusInterfaceInfo -> IO (Maybe [DBusPropertyInfo]))
-> IO (Maybe [DBusPropertyInfo])
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr DBusPropertyInfo)
val <- Ptr (Ptr (Ptr DBusPropertyInfo)) -> IO (Ptr (Ptr DBusPropertyInfo))
forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusPropertyInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) :: IO (Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
Maybe [DBusPropertyInfo]
result <- Ptr (Ptr DBusPropertyInfo)
-> (Ptr (Ptr DBusPropertyInfo) -> IO [DBusPropertyInfo])
-> IO (Maybe [DBusPropertyInfo])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusPropertyInfo)
val ((Ptr (Ptr DBusPropertyInfo) -> IO [DBusPropertyInfo])
-> IO (Maybe [DBusPropertyInfo]))
-> (Ptr (Ptr DBusPropertyInfo) -> IO [DBusPropertyInfo])
-> IO (Maybe [DBusPropertyInfo])
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr (Ptr DBusPropertyInfo)
val' -> do
[Ptr DBusPropertyInfo]
val'' <- Ptr (Ptr DBusPropertyInfo) -> IO [Ptr DBusPropertyInfo]
forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusPropertyInfo)
val'
[DBusPropertyInfo]
val''' <- (Ptr DBusPropertyInfo -> IO DBusPropertyInfo)
-> [Ptr DBusPropertyInfo] -> IO [DBusPropertyInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr DBusPropertyInfo -> DBusPropertyInfo)
-> Ptr DBusPropertyInfo -> IO DBusPropertyInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusPropertyInfo -> DBusPropertyInfo
Gio.DBusPropertyInfo.DBusPropertyInfo) [Ptr DBusPropertyInfo]
val''
[DBusPropertyInfo] -> IO [DBusPropertyInfo]
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusPropertyInfo]
val'''
Maybe [DBusPropertyInfo] -> IO (Maybe [DBusPropertyInfo])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusPropertyInfo]
result
setDBusInterfaceInfoProperties :: MonadIO m => DBusInterfaceInfo -> Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo) -> m ()
setDBusInterfaceInfoProperties :: DBusInterfaceInfo -> Ptr (Ptr DBusPropertyInfo) -> m ()
setDBusInterfaceInfoProperties s :: DBusInterfaceInfo
s val :: Ptr (Ptr DBusPropertyInfo)
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr (Ptr DBusPropertyInfo))
-> Ptr (Ptr DBusPropertyInfo) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusPropertyInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (Ptr (Ptr DBusPropertyInfo)
val :: Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
clearDBusInterfaceInfoProperties :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoProperties :: DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoProperties s :: DBusInterfaceInfo
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr (Ptr DBusPropertyInfo))
-> Ptr (Ptr DBusPropertyInfo) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusPropertyInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 32) (Ptr (Ptr DBusPropertyInfo)
forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
#if ENABLE_OVERLOADING
data DBusInterfaceInfoPropertiesFieldInfo
instance AttrInfo DBusInterfaceInfoPropertiesFieldInfo where
type AttrAllowedOps DBusInterfaceInfoPropertiesFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoPropertiesFieldInfo = (~) (Ptr (Ptr Gio.DBusPropertyInfo.DBusPropertyInfo))
type AttrBaseTypeConstraint DBusInterfaceInfoPropertiesFieldInfo = (~) DBusInterfaceInfo
type AttrGetType DBusInterfaceInfoPropertiesFieldInfo = Maybe [Gio.DBusPropertyInfo.DBusPropertyInfo]
type AttrLabel DBusInterfaceInfoPropertiesFieldInfo = "properties"
type AttrOrigin DBusInterfaceInfoPropertiesFieldInfo = DBusInterfaceInfo
attrGet _ = getDBusInterfaceInfoProperties
attrSet _ = setDBusInterfaceInfoProperties
attrConstruct = undefined
attrClear _ = clearDBusInterfaceInfoProperties
dBusInterfaceInfo_properties :: AttrLabelProxy "properties"
dBusInterfaceInfo_properties = AttrLabelProxy
#endif
getDBusInterfaceInfoAnnotations :: MonadIO m => DBusInterfaceInfo -> m (Maybe [Gio.DBusAnnotationInfo.DBusAnnotationInfo])
getDBusInterfaceInfoAnnotations :: DBusInterfaceInfo -> m (Maybe [DBusAnnotationInfo])
getDBusInterfaceInfoAnnotations s :: DBusInterfaceInfo
s = IO (Maybe [DBusAnnotationInfo]) -> m (Maybe [DBusAnnotationInfo])
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe [DBusAnnotationInfo]) -> m (Maybe [DBusAnnotationInfo]))
-> IO (Maybe [DBusAnnotationInfo])
-> m (Maybe [DBusAnnotationInfo])
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo
-> (Ptr DBusInterfaceInfo -> IO (Maybe [DBusAnnotationInfo]))
-> IO (Maybe [DBusAnnotationInfo])
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO (Maybe [DBusAnnotationInfo]))
-> IO (Maybe [DBusAnnotationInfo]))
-> (Ptr DBusInterfaceInfo -> IO (Maybe [DBusAnnotationInfo]))
-> IO (Maybe [DBusAnnotationInfo])
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr DBusAnnotationInfo)
val <- Ptr (Ptr (Ptr DBusAnnotationInfo))
-> IO (Ptr (Ptr DBusAnnotationInfo))
forall a. Storable a => Ptr a -> IO a
peek (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusAnnotationInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) :: IO (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
Maybe [DBusAnnotationInfo]
result <- Ptr (Ptr DBusAnnotationInfo)
-> (Ptr (Ptr DBusAnnotationInfo) -> IO [DBusAnnotationInfo])
-> IO (Maybe [DBusAnnotationInfo])
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
SP.convertIfNonNull Ptr (Ptr DBusAnnotationInfo)
val ((Ptr (Ptr DBusAnnotationInfo) -> IO [DBusAnnotationInfo])
-> IO (Maybe [DBusAnnotationInfo]))
-> (Ptr (Ptr DBusAnnotationInfo) -> IO [DBusAnnotationInfo])
-> IO (Maybe [DBusAnnotationInfo])
forall a b. (a -> b) -> a -> b
$ \val' :: Ptr (Ptr DBusAnnotationInfo)
val' -> do
[Ptr DBusAnnotationInfo]
val'' <- Ptr (Ptr DBusAnnotationInfo) -> IO [Ptr DBusAnnotationInfo]
forall a. Ptr (Ptr a) -> IO [Ptr a]
unpackZeroTerminatedPtrArray Ptr (Ptr DBusAnnotationInfo)
val'
[DBusAnnotationInfo]
val''' <- (Ptr DBusAnnotationInfo -> IO DBusAnnotationInfo)
-> [Ptr DBusAnnotationInfo] -> IO [DBusAnnotationInfo]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM ((ManagedPtr DBusAnnotationInfo -> DBusAnnotationInfo)
-> Ptr DBusAnnotationInfo -> IO DBusAnnotationInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusAnnotationInfo -> DBusAnnotationInfo
Gio.DBusAnnotationInfo.DBusAnnotationInfo) [Ptr DBusAnnotationInfo]
val''
[DBusAnnotationInfo] -> IO [DBusAnnotationInfo]
forall (m :: * -> *) a. Monad m => a -> m a
return [DBusAnnotationInfo]
val'''
Maybe [DBusAnnotationInfo] -> IO (Maybe [DBusAnnotationInfo])
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe [DBusAnnotationInfo]
result
setDBusInterfaceInfoAnnotations :: MonadIO m => DBusInterfaceInfo -> Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo) -> m ()
setDBusInterfaceInfoAnnotations :: DBusInterfaceInfo -> Ptr (Ptr DBusAnnotationInfo) -> m ()
setDBusInterfaceInfoAnnotations s :: DBusInterfaceInfo
s val :: Ptr (Ptr DBusAnnotationInfo)
val = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr (Ptr DBusAnnotationInfo))
-> Ptr (Ptr DBusAnnotationInfo) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusAnnotationInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (Ptr (Ptr DBusAnnotationInfo)
val :: Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
clearDBusInterfaceInfoAnnotations :: MonadIO m => DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoAnnotations :: DBusInterfaceInfo -> m ()
clearDBusInterfaceInfoAnnotations s :: DBusInterfaceInfo
s = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DBusInterfaceInfo -> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr DBusInterfaceInfo
s ((Ptr DBusInterfaceInfo -> IO ()) -> IO ())
-> (Ptr DBusInterfaceInfo -> IO ()) -> IO ()
forall a b. (a -> b) -> a -> b
$ \ptr :: Ptr DBusInterfaceInfo
ptr -> do
Ptr (Ptr (Ptr DBusAnnotationInfo))
-> Ptr (Ptr DBusAnnotationInfo) -> IO ()
forall a. Storable a => Ptr a -> a -> IO ()
poke (Ptr DBusInterfaceInfo
ptr Ptr DBusInterfaceInfo -> Int -> Ptr (Ptr (Ptr DBusAnnotationInfo))
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` 40) (Ptr (Ptr DBusAnnotationInfo)
forall a. Ptr a
FP.nullPtr :: Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
#if ENABLE_OVERLOADING
data DBusInterfaceInfoAnnotationsFieldInfo
instance AttrInfo DBusInterfaceInfoAnnotationsFieldInfo where
type AttrAllowedOps DBusInterfaceInfoAnnotationsFieldInfo = '[ 'AttrSet, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DBusInterfaceInfoAnnotationsFieldInfo = (~) (Ptr (Ptr Gio.DBusAnnotationInfo.DBusAnnotationInfo))
type AttrBaseTypeConstraint DBusInterfaceInfoAnnotationsFieldInfo = (~) DBusInterfaceInfo
type AttrGetType DBusInterfaceInfoAnnotationsFieldInfo = Maybe [Gio.DBusAnnotationInfo.DBusAnnotationInfo]
type AttrLabel DBusInterfaceInfoAnnotationsFieldInfo = "annotations"
type AttrOrigin DBusInterfaceInfoAnnotationsFieldInfo = DBusInterfaceInfo
attrGet _ = getDBusInterfaceInfoAnnotations
attrSet _ = setDBusInterfaceInfoAnnotations
attrConstruct = undefined
attrClear _ = clearDBusInterfaceInfoAnnotations
dBusInterfaceInfo_annotations :: AttrLabelProxy "annotations"
dBusInterfaceInfo_annotations = AttrLabelProxy
#endif
#if 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, *)])
#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 :: DBusInterfaceInfo -> m ()
dBusInterfaceInfoCacheBuild info :: DBusInterfaceInfo
info = 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 DBusInterfaceInfo
info' <- DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr DBusInterfaceInfo -> IO ()
g_dbus_interface_info_cache_build Ptr DBusInterfaceInfo
info'
DBusInterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data DBusInterfaceInfoCacheBuildMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DBusInterfaceInfoCacheBuildMethodInfo DBusInterfaceInfo signature where
overloadedMethod _ = 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 :: DBusInterfaceInfo -> m ()
dBusInterfaceInfoCacheRelease info :: DBusInterfaceInfo
info = 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 DBusInterfaceInfo
info' <- DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr DBusInterfaceInfo -> IO ()
g_dbus_interface_info_cache_release Ptr DBusInterfaceInfo
info'
DBusInterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data DBusInterfaceInfoCacheReleaseMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DBusInterfaceInfoCacheReleaseMethodInfo DBusInterfaceInfo signature where
overloadedMethod _ = 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 :: DBusInterfaceInfo -> Word32 -> String -> m ()
dBusInterfaceInfoGenerateXml info :: DBusInterfaceInfo
info indent :: Word32
indent stringBuilder :: String
stringBuilder = 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 DBusInterfaceInfo
info' <- DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr String
stringBuilder' <- String -> IO (Ptr String)
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'
DBusInterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
String -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr String
stringBuilder
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data DBusInterfaceInfoGenerateXmlMethodInfo
instance (signature ~ (Word32 -> GLib.String.String -> m ()), MonadIO m) => O.MethodInfo DBusInterfaceInfoGenerateXmlMethodInfo DBusInterfaceInfo signature where
overloadedMethod _ = 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 Gio.DBusMethodInfo.DBusMethodInfo
dBusInterfaceInfoLookupMethod :: DBusInterfaceInfo -> Text -> m DBusMethodInfo
dBusInterfaceInfoLookupMethod info :: DBusInterfaceInfo
info name :: Text
name = IO DBusMethodInfo -> m DBusMethodInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusMethodInfo -> m DBusMethodInfo)
-> IO DBusMethodInfo -> m DBusMethodInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
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'
Text -> Ptr DBusMethodInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dBusInterfaceInfoLookupMethod" Ptr DBusMethodInfo
result
DBusMethodInfo
result' <- ((ManagedPtr DBusMethodInfo -> DBusMethodInfo)
-> Ptr DBusMethodInfo -> IO DBusMethodInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusMethodInfo -> DBusMethodInfo
Gio.DBusMethodInfo.DBusMethodInfo) Ptr DBusMethodInfo
result
DBusInterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
DBusMethodInfo -> IO DBusMethodInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DBusMethodInfo
result'
#if ENABLE_OVERLOADING
data DBusInterfaceInfoLookupMethodMethodInfo
instance (signature ~ (T.Text -> m Gio.DBusMethodInfo.DBusMethodInfo), MonadIO m) => O.MethodInfo DBusInterfaceInfoLookupMethodMethodInfo DBusInterfaceInfo signature where
overloadedMethod _ = 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 Gio.DBusPropertyInfo.DBusPropertyInfo
dBusInterfaceInfoLookupProperty :: DBusInterfaceInfo -> Text -> m DBusPropertyInfo
dBusInterfaceInfoLookupProperty info :: DBusInterfaceInfo
info name :: Text
name = IO DBusPropertyInfo -> m DBusPropertyInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusPropertyInfo -> m DBusPropertyInfo)
-> IO DBusPropertyInfo -> m DBusPropertyInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
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'
Text -> Ptr DBusPropertyInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dBusInterfaceInfoLookupProperty" Ptr DBusPropertyInfo
result
DBusPropertyInfo
result' <- ((ManagedPtr DBusPropertyInfo -> DBusPropertyInfo)
-> Ptr DBusPropertyInfo -> IO DBusPropertyInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusPropertyInfo -> DBusPropertyInfo
Gio.DBusPropertyInfo.DBusPropertyInfo) Ptr DBusPropertyInfo
result
DBusInterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
DBusPropertyInfo -> IO DBusPropertyInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DBusPropertyInfo
result'
#if ENABLE_OVERLOADING
data DBusInterfaceInfoLookupPropertyMethodInfo
instance (signature ~ (T.Text -> m Gio.DBusPropertyInfo.DBusPropertyInfo), MonadIO m) => O.MethodInfo DBusInterfaceInfoLookupPropertyMethodInfo DBusInterfaceInfo signature where
overloadedMethod _ = 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 Gio.DBusSignalInfo.DBusSignalInfo
dBusInterfaceInfoLookupSignal :: DBusInterfaceInfo -> Text -> m DBusSignalInfo
dBusInterfaceInfoLookupSignal info :: DBusInterfaceInfo
info name :: Text
name = IO DBusSignalInfo -> m DBusSignalInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusSignalInfo -> m DBusSignalInfo)
-> IO DBusSignalInfo -> m DBusSignalInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
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'
Text -> Ptr DBusSignalInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dBusInterfaceInfoLookupSignal" Ptr DBusSignalInfo
result
DBusSignalInfo
result' <- ((ManagedPtr DBusSignalInfo -> DBusSignalInfo)
-> Ptr DBusSignalInfo -> IO DBusSignalInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr DBusSignalInfo -> DBusSignalInfo
Gio.DBusSignalInfo.DBusSignalInfo) Ptr DBusSignalInfo
result
DBusInterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
name'
DBusSignalInfo -> IO DBusSignalInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DBusSignalInfo
result'
#if ENABLE_OVERLOADING
data DBusInterfaceInfoLookupSignalMethodInfo
instance (signature ~ (T.Text -> m Gio.DBusSignalInfo.DBusSignalInfo), MonadIO m) => O.MethodInfo DBusInterfaceInfoLookupSignalMethodInfo DBusInterfaceInfo signature where
overloadedMethod _ = 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 :: DBusInterfaceInfo -> m DBusInterfaceInfo
dBusInterfaceInfoRef info :: DBusInterfaceInfo
info = IO DBusInterfaceInfo -> m DBusInterfaceInfo
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO DBusInterfaceInfo -> m DBusInterfaceInfo)
-> IO DBusInterfaceInfo -> m DBusInterfaceInfo
forall a b. (a -> b) -> a -> b
$ do
Ptr DBusInterfaceInfo
info' <- DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
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'
Text -> Ptr DBusInterfaceInfo -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "dBusInterfaceInfoRef" Ptr DBusInterfaceInfo
result
DBusInterfaceInfo
result' <- ((ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo)
-> Ptr DBusInterfaceInfo -> IO DBusInterfaceInfo
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr DBusInterfaceInfo -> DBusInterfaceInfo
DBusInterfaceInfo) Ptr DBusInterfaceInfo
result
DBusInterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
DBusInterfaceInfo -> IO DBusInterfaceInfo
forall (m :: * -> *) a. Monad m => a -> m a
return DBusInterfaceInfo
result'
#if ENABLE_OVERLOADING
data DBusInterfaceInfoRefMethodInfo
instance (signature ~ (m DBusInterfaceInfo), MonadIO m) => O.MethodInfo DBusInterfaceInfoRefMethodInfo DBusInterfaceInfo signature where
overloadedMethod _ = 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 :: DBusInterfaceInfo -> m ()
dBusInterfaceInfoUnref info :: DBusInterfaceInfo
info = 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 DBusInterfaceInfo
info' <- DBusInterfaceInfo -> IO (Ptr DBusInterfaceInfo)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr DBusInterfaceInfo
info
Ptr DBusInterfaceInfo -> IO ()
g_dbus_interface_info_unref Ptr DBusInterfaceInfo
info'
DBusInterfaceInfo -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr DBusInterfaceInfo
info
() -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
#if ENABLE_OVERLOADING
data DBusInterfaceInfoUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo DBusInterfaceInfoUnrefMethodInfo DBusInterfaceInfo signature where
overloadedMethod _ = dBusInterfaceInfoUnref
#endif
#if ENABLE_OVERLOADING
type family ResolveDBusInterfaceInfoMethod (t :: Symbol) (o :: *) :: * 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.MethodInfo info DBusInterfaceInfo p) => O.IsLabelProxy t (DBusInterfaceInfo -> p) where
fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveDBusInterfaceInfoMethod t DBusInterfaceInfo, O.MethodInfo info DBusInterfaceInfo p) => O.IsLabel t (DBusInterfaceInfo -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
#endif